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

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

@@ -0,0 +1,2822 @@
+///
+/// AudioBrowser-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `AndroidAudioContentType` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class AndroidAudioContentType; }
+// Forward declaration of `AndroidAudioOffloadSettings` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct AndroidAudioOffloadSettings; }
+// Forward declaration of `AndroidOptions` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct AndroidOptions; }
+// Forward declaration of `AndroidPlayerWakeMode` to properly resolve imports.
+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 `ArtworkRequestConfig` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct ArtworkRequestConfig; }
+// Forward declaration of `BatteryOptimizationStatusChangedEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct BatteryOptimizationStatusChangedEvent; }
+// Forward declaration of `BatteryOptimizationStatus` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class BatteryOptimizationStatus; }
+// Forward declaration of `BatteryWarningPendingChangedEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct BatteryWarningPendingChangedEvent; }
+// Forward declaration of `BrowseError` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct BrowseError; }
+// Forward declaration of `BrowserSourceCallbackParam` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct BrowserSourceCallbackParam; }
+// Forward declaration of `CarPlayNowPlayingButton` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class CarPlayNowPlayingButton; }
+// 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 `FormatNavigationErrorParams` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct FormatNavigationErrorParams; }
+// Forward declaration of `FormattedNavigationError` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct FormattedNavigationError; }
+// Forward declaration of `HeartRating` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct HeartRating; }
+// Forward declaration of `HttpMethod` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class HttpMethod; }
+// Forward declaration of `HybridAudioBrowserSpec` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { class HybridAudioBrowserSpec; }
+// Forward declaration of `IOSCategoryMode` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class IOSCategoryMode; }
+// Forward declaration of `IOSCategoryOptions` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class IOSCategoryOptions; }
+// Forward declaration of `IOSCategoryPolicy` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class IOSCategoryPolicy; }
+// Forward declaration of `IOSCategory` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class IOSCategory; }
+// Forward declaration of `ImageContext` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct ImageContext; }
+// Forward declaration of `ImageQueryParams` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct ImageQueryParams; }
+// Forward declaration of `ImageSource` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct ImageSource; }
+// Forward declaration of `IosOutputType` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class IosOutputType; }
+// Forward declaration of `IosOutput` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct IosOutput; }
+// Forward declaration of `MediaRequestConfig` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct MediaRequestConfig; }
+// Forward declaration of `MediaTransformParams` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct MediaTransformParams; }
+// Forward declaration of `NativeRouteEntry` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct NativeRouteEntry; }
+// Forward declaration of `NavigationErrorEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct NavigationErrorEvent; }
+// Forward declaration of `NavigationErrorType` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class NavigationErrorType; }
+// Forward declaration of `NavigationError` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct NavigationError; }
+// 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 `Options` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct Options; }
+// Forward declaration of `PercentageRating` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PercentageRating; }
+// Forward declaration of `PlaybackActiveTrackChangedEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PlaybackActiveTrackChangedEvent; }
+// Forward declaration of `PlaybackErrorEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PlaybackErrorEvent; }
+// Forward declaration of `PlaybackError` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PlaybackError; }
+// Forward declaration of `PlaybackPlayWhenReadyChangedEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PlaybackPlayWhenReadyChangedEvent; }
+// Forward declaration of `PlaybackProgressUpdatedEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PlaybackProgressUpdatedEvent; }
+// Forward declaration of `PlaybackQueueEndedEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PlaybackQueueEndedEvent; }
+// Forward declaration of `PlaybackState` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class PlaybackState; }
+// Forward declaration of `Playback` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct Playback; }
+// Forward declaration of `PlayerCapabilities` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PlayerCapabilities; }
+// Forward declaration of `PlayingState` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct PlayingState; }
+// Forward declaration of `Progress` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct Progress; }
+// Forward declaration of `RatingType` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class RatingType; }
+// Forward declaration of `RemoteJumpBackwardEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RemoteJumpBackwardEvent; }
+// Forward declaration of `RemoteJumpForwardEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RemoteJumpForwardEvent; }
+// Forward declaration of `RemotePlayIdEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RemotePlayIdEvent; }
+// Forward declaration of `RemotePlaySearchEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RemotePlaySearchEvent; }
+// Forward declaration of `RemoteSeekEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RemoteSeekEvent; }
+// Forward declaration of `RemoteSetRatingEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RemoteSetRatingEvent; }
+// Forward declaration of `RemoteSkipEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RemoteSkipEvent; }
+// Forward declaration of `RepeatModeChangedEvent` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RepeatModeChangedEvent; }
+// Forward declaration of `RepeatMode` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class RepeatMode; }
+// Forward declaration of `RequestConfig` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RequestConfig; }
+// Forward declaration of `ResolvedTrack` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct ResolvedTrack; }
+// Forward declaration of `RetryConfig` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct RetryConfig; }
+// Forward declaration of `SearchMode` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class SearchMode; }
+// Forward declaration of `SearchParams` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct SearchParams; }
+// 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 `StarRating` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct StarRating; }
+// Forward declaration of `ThumbsRating` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct ThumbsRating; }
+// Forward declaration of `TimedMetadata` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct TimedMetadata; }
+// Forward declaration of `TrackMetadata` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct TrackMetadata; }
+// Forward declaration of `TrackStyle` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class TrackStyle; }
+// Forward declaration of `Track` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct Track; }
+// Forward declaration of `TransformableRequestConfig` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct TransformableRequestConfig; }
+// Forward declaration of `UpdateOptions` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { struct UpdateOptions; }
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridAudioBrowserSpec_cxx` to properly resolve imports.
+namespace AudioBrowser { class HybridAudioBrowserSpec_cxx; }
+
+// Include C++ defined types
+#include "AndroidAudioContentType.hpp"
+#include "AndroidAudioOffloadSettings.hpp"
+#include "AndroidOptions.hpp"
+#include "AndroidPlayerWakeMode.hpp"
+#include "AppKilledPlaybackBehavior.hpp"
+#include "ArtworkRequestConfig.hpp"
+#include "BatteryOptimizationStatus.hpp"
+#include "BatteryOptimizationStatusChangedEvent.hpp"
+#include "BatteryWarningPendingChangedEvent.hpp"
+#include "BrowseError.hpp"
+#include "BrowserSourceCallbackParam.hpp"
+#include "CarPlayNowPlayingButton.hpp"
+#include "ChapterMetadata.hpp"
+#include "EqualizerSettings.hpp"
+#include "FavoriteChangedEvent.hpp"
+#include "FormatNavigationErrorParams.hpp"
+#include "FormattedNavigationError.hpp"
+#include "HeartRating.hpp"
+#include "HttpMethod.hpp"
+#include "HybridAudioBrowserSpec.hpp"
+#include "IOSCategory.hpp"
+#include "IOSCategoryMode.hpp"
+#include "IOSCategoryOptions.hpp"
+#include "IOSCategoryPolicy.hpp"
+#include "ImageContext.hpp"
+#include "ImageQueryParams.hpp"
+#include "ImageSource.hpp"
+#include "IosOutput.hpp"
+#include "IosOutputType.hpp"
+#include "MediaRequestConfig.hpp"
+#include "MediaTransformParams.hpp"
+#include "NativeRouteEntry.hpp"
+#include "NavigationError.hpp"
+#include "NavigationErrorEvent.hpp"
+#include "NavigationErrorType.hpp"
+#include "NotificationButton.hpp"
+#include "NotificationButtonLayout.hpp"
+#include "NowPlayingMetadata.hpp"
+#include "Options.hpp"
+#include "PercentageRating.hpp"
+#include "Playback.hpp"
+#include "PlaybackActiveTrackChangedEvent.hpp"
+#include "PlaybackError.hpp"
+#include "PlaybackErrorEvent.hpp"
+#include "PlaybackPlayWhenReadyChangedEvent.hpp"
+#include "PlaybackProgressUpdatedEvent.hpp"
+#include "PlaybackQueueEndedEvent.hpp"
+#include "PlaybackState.hpp"
+#include "PlayerCapabilities.hpp"
+#include "PlayingState.hpp"
+#include "Progress.hpp"
+#include "RatingType.hpp"
+#include "RemoteJumpBackwardEvent.hpp"
+#include "RemoteJumpForwardEvent.hpp"
+#include "RemotePlayIdEvent.hpp"
+#include "RemotePlaySearchEvent.hpp"
+#include "RemoteSeekEvent.hpp"
+#include "RemoteSetRatingEvent.hpp"
+#include "RemoteSkipEvent.hpp"
+#include "RepeatMode.hpp"
+#include "RepeatModeChangedEvent.hpp"
+#include "RequestConfig.hpp"
+#include "ResolvedTrack.hpp"
+#include "RetryConfig.hpp"
+#include "SearchMode.hpp"
+#include "SearchParams.hpp"
+#include "SleepTimerEndOfTrack.hpp"
+#include "SleepTimerTime.hpp"
+#include "StarRating.hpp"
+#include "ThumbsRating.hpp"
+#include "TimedMetadata.hpp"
+#include "Track.hpp"
+#include "TrackMetadata.hpp"
+#include "TrackStyle.hpp"
+#include "TransformableRequestConfig.hpp"
+#include "UpdateOptions.hpp"
+#include <NitroModules/Null.hpp>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/PromiseHolder.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+/**
+ * Contains specialized versions of C++ templated types so they can be accessed from Swift,
+ * as well as helper functions to interact with those C++ types from Swift.
+ */
+namespace margelo::nitro::audiobrowser::bridge::swift {
+
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<ImageSource>
+  /**
+   * Specialized version of `std::optional<ImageSource>`.
+   */
+  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_ImageSource_(const std::optional<ImageSource>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ImageSource get_std__optional_ImageSource_(const std::optional<ImageSource>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<HttpMethod>
+  /**
+   * Specialized version of `std::optional<HttpMethod>`.
+   */
+  using std__optional_HttpMethod_ = std::optional<HttpMethod>;
+  inline std::optional<HttpMethod> create_std__optional_HttpMethod_(const HttpMethod& value) noexcept {
+    return std::optional<HttpMethod>(value);
+  }
+  inline bool has_value_std__optional_HttpMethod_(const std::optional<HttpMethod>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline HttpMethod get_std__optional_HttpMethod_(const std::optional<HttpMethod>& optional) noexcept {
+    return *optional;
+  }
+  
+  // 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;
+  }
+  
+  // pragma MARK: std::unordered_map<std::string, std::string>
+  /**
+   * Specialized version of `std::unordered_map<std::string, std::string>`.
+   */
+  using std__unordered_map_std__string__std__string_ = std::unordered_map<std::string, std::string>;
+  inline std::unordered_map<std::string, std::string> create_std__unordered_map_std__string__std__string_(size_t size) noexcept {
+    std::unordered_map<std::string, std::string> map;
+    map.reserve(size);
+    return map;
+  }
+  inline std::vector<std::string> get_std__unordered_map_std__string__std__string__keys(const std__unordered_map_std__string__std__string_& map) noexcept {
+    std::vector<std::string> keys;
+    keys.reserve(map.size());
+    for (const auto& entry : map) {
+      keys.push_back(entry.first);
+    }
+    return keys;
+  }
+  inline std::string get_std__unordered_map_std__string__std__string__value(const std__unordered_map_std__string__std__string_& map, const std::string& key) noexcept {
+    return map.find(key)->second;
+  }
+  inline void emplace_std__unordered_map_std__string__std__string_(std__unordered_map_std__string__std__string_& map, const std::string& key, const std::string& value) noexcept {
+    map.emplace(key, 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;
+  }
+  
+  // pragma MARK: std::optional<double>
+  /**
+   * Specialized version of `std::optional<double>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
+    return std::optional<double>(value);
+  }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<TrackStyle>
+  /**
+   * Specialized version of `std::optional<TrackStyle>`.
+   */
+  using std__optional_TrackStyle_ = std::optional<TrackStyle>;
+  inline std::optional<TrackStyle> create_std__optional_TrackStyle_(const TrackStyle& value) noexcept {
+    return std::optional<TrackStyle>(value);
+  }
+  inline bool has_value_std__optional_TrackStyle_(const std::optional<TrackStyle>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline TrackStyle get_std__optional_TrackStyle_(const std::optional<TrackStyle>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::vector<Track>
+  /**
+   * Specialized version of `std::vector<Track>`.
+   */
+  using std__vector_Track_ = std::vector<Track>;
+  inline std::vector<Track> create_std__vector_Track_(size_t size) noexcept {
+    std::vector<Track> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<std::vector<Track>>
+  /**
+   * Specialized version of `std::optional<std::vector<Track>>`.
+   */
+  using std__optional_std__vector_Track__ = std::optional<std::vector<Track>>;
+  inline std::optional<std::vector<Track>> create_std__optional_std__vector_Track__(const std::vector<Track>& value) noexcept {
+    return std::optional<std::vector<Track>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_Track__(const std::optional<std::vector<Track>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<Track> get_std__optional_std__vector_Track__(const std::optional<std::vector<Track>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<Track>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<Track>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_Track___ = std::shared_ptr<Promise<std::vector<Track>>>;
+  inline std::shared_ptr<Promise<std::vector<Track>>> create_std__shared_ptr_Promise_std__vector_Track___() noexcept {
+    return Promise<std::vector<Track>>::create();
+  }
+  inline PromiseHolder<std::vector<Track>> wrap_std__shared_ptr_Promise_std__vector_Track___(std::shared_ptr<Promise<std::vector<Track>>> promise) noexcept {
+    return PromiseHolder<std::vector<Track>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<Track>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<Track>&)>`.
+   */
+  using Func_void_std__vector_Track_ = std::function<void(const std::vector<Track>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<Track>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_Track__Wrapper final {
+  public:
+    explicit Func_void_std__vector_Track__Wrapper(std::function<void(const std::vector<Track>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<Track>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<Track> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<Track>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_Track_ create_Func_void_std__vector_Track_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_Track__Wrapper wrap_Func_void_std__vector_Track_(Func_void_std__vector_Track_ value) noexcept {
+    return Func_void_std__vector_Track__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
+   */
+  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__exception_ptr_Wrapper final {
+  public:
+    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::exception_ptr& /* error */)>>(std::move(func))) {}
+    inline void call(std::exception_ptr error) const noexcept {
+      _function->operator()(error);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::exception_ptr& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__exception_ptr_Wrapper wrap_Func_void_std__exception_ptr(Func_void_std__exception_ptr value) noexcept {
+    return Func_void_std__exception_ptr_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<ResolvedTrack>
+  /**
+   * Specialized version of `std::optional<ResolvedTrack>`.
+   */
+  using std__optional_ResolvedTrack_ = std::optional<ResolvedTrack>;
+  inline std::optional<ResolvedTrack> create_std__optional_ResolvedTrack_(const ResolvedTrack& value) noexcept {
+    return std::optional<ResolvedTrack>(value);
+  }
+  inline bool has_value_std__optional_ResolvedTrack_(const std::optional<ResolvedTrack>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ResolvedTrack get_std__optional_ResolvedTrack_(const std::optional<ResolvedTrack>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const std::string& /* path */)>
+  /**
+   * Specialized version of `std::function<void(const std::string&)>`.
+   */
+  using Func_void_std__string = std::function<void(const std::string& /* path */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::string& / * path * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__string_Wrapper final {
+  public:
+    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* path */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* path */)>>(std::move(func))) {}
+    inline void call(std::string path) const noexcept {
+      _function->operator()(path);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::string& /* path */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) noexcept {
+    return Func_void_std__string_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<ResolvedTrack>& /* content */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<ResolvedTrack>&)>`.
+   */
+  using Func_void_std__optional_ResolvedTrack_ = std::function<void(const std::optional<ResolvedTrack>& /* content */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<ResolvedTrack>& / * content * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_ResolvedTrack__Wrapper final {
+  public:
+    explicit Func_void_std__optional_ResolvedTrack__Wrapper(std::function<void(const std::optional<ResolvedTrack>& /* content */)>&& func): _function(std::make_unique<std::function<void(const std::optional<ResolvedTrack>& /* content */)>>(std::move(func))) {}
+    inline void call(std::optional<ResolvedTrack> content) const noexcept {
+      _function->operator()(content);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<ResolvedTrack>& /* content */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__optional_ResolvedTrack_ create_Func_void_std__optional_ResolvedTrack_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_ResolvedTrack__Wrapper wrap_Func_void_std__optional_ResolvedTrack_(Func_void_std__optional_ResolvedTrack_ value) noexcept {
+    return Func_void_std__optional_ResolvedTrack__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<NavigationError>
+  /**
+   * Specialized version of `std::optional<NavigationError>`.
+   */
+  using std__optional_NavigationError_ = std::optional<NavigationError>;
+  inline std::optional<NavigationError> create_std__optional_NavigationError_(const NavigationError& value) noexcept {
+    return std::optional<NavigationError>(value);
+  }
+  inline bool has_value_std__optional_NavigationError_(const std::optional<NavigationError>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline NavigationError get_std__optional_NavigationError_(const std::optional<NavigationError>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const NavigationErrorEvent& /* data */)>
+  /**
+   * Specialized version of `std::function<void(const NavigationErrorEvent&)>`.
+   */
+  using Func_void_NavigationErrorEvent = std::function<void(const NavigationErrorEvent& /* data */)>;
+  /**
+   * Wrapper class for a `std::function<void(const NavigationErrorEvent& / * data * /)>`, this can be used from Swift.
+   */
+  class Func_void_NavigationErrorEvent_Wrapper final {
+  public:
+    explicit Func_void_NavigationErrorEvent_Wrapper(std::function<void(const NavigationErrorEvent& /* data */)>&& func): _function(std::make_unique<std::function<void(const NavigationErrorEvent& /* data */)>>(std::move(func))) {}
+    inline void call(NavigationErrorEvent data) const noexcept {
+      _function->operator()(data);
+    }
+  private:
+    std::unique_ptr<std::function<void(const NavigationErrorEvent& /* data */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_NavigationErrorEvent create_Func_void_NavigationErrorEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_NavigationErrorEvent_Wrapper wrap_Func_void_NavigationErrorEvent(Func_void_NavigationErrorEvent value) noexcept {
+    return Func_void_NavigationErrorEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<FormattedNavigationError>
+  /**
+   * Specialized version of `std::optional<FormattedNavigationError>`.
+   */
+  using std__optional_FormattedNavigationError_ = std::optional<FormattedNavigationError>;
+  inline std::optional<FormattedNavigationError> create_std__optional_FormattedNavigationError_(const FormattedNavigationError& value) noexcept {
+    return std::optional<FormattedNavigationError>(value);
+  }
+  inline bool has_value_std__optional_FormattedNavigationError_(const std::optional<FormattedNavigationError>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline FormattedNavigationError get_std__optional_FormattedNavigationError_(const std::optional<FormattedNavigationError>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<FormattedNavigationError>& /* formattedError */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<FormattedNavigationError>&)>`.
+   */
+  using Func_void_std__optional_FormattedNavigationError_ = std::function<void(const std::optional<FormattedNavigationError>& /* formattedError */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<FormattedNavigationError>& / * formattedError * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_FormattedNavigationError__Wrapper final {
+  public:
+    explicit Func_void_std__optional_FormattedNavigationError__Wrapper(std::function<void(const std::optional<FormattedNavigationError>& /* formattedError */)>&& func): _function(std::make_unique<std::function<void(const std::optional<FormattedNavigationError>& /* formattedError */)>>(std::move(func))) {}
+    inline void call(std::optional<FormattedNavigationError> formattedError) const noexcept {
+      _function->operator()(formattedError);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<FormattedNavigationError>& /* formattedError */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__optional_FormattedNavigationError_ create_Func_void_std__optional_FormattedNavigationError_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_FormattedNavigationError__Wrapper wrap_Func_void_std__optional_FormattedNavigationError_(Func_void_std__optional_FormattedNavigationError_ value) noexcept {
+    return Func_void_std__optional_FormattedNavigationError__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<std::string>
+  /**
+   * Specialized version of `std::vector<std::string>`.
+   */
+  using std__vector_std__string_ = std::vector<std::string>;
+  inline std::vector<std::string> create_std__vector_std__string_(size_t size) noexcept {
+    std::vector<std::string> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<TransformableRequestConfig>
+  /**
+   * Specialized version of `std::optional<TransformableRequestConfig>`.
+   */
+  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;
+  }
+  
+  // 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::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__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;
+  }
+  
+  // 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 */)>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const RequestConfig&, const std::optional<std::unordered_map<std::string, std::string>>&)>`.
+   */
+  using Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string__ = 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 */)>;
+  /**
+   * Wrapper class for a `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 * /)>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string___Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string___Wrapper(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 */)>&& func): _function(std::make_unique<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::move(func))) {}
+    inline std::shared_ptr<Promise<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<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_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string__ create_Func_std__shared_ptr_Promise_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_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string___Wrapper wrap_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string__(Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string__ value) noexcept {
+    return Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____RequestConfig_std__optional_std__unordered_map_std__string__std__string___Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>`.
+   */
+  using std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig____ = std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>> create_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig____() noexcept {
+    return Promise<std::shared_ptr<Promise<RequestConfig>>>::create();
+  }
+  inline PromiseHolder<std::shared_ptr<Promise<RequestConfig>>> wrap_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig____(std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>> promise) noexcept {
+    return PromiseHolder<std::shared_ptr<Promise<RequestConfig>>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<Promise<RequestConfig>>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::shared_ptr<Promise<RequestConfig>>&)>`.
+   */
+  using Func_void_std__shared_ptr_Promise_RequestConfig__ = std::function<void(const std::shared_ptr<Promise<RequestConfig>>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::shared_ptr<Promise<RequestConfig>>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__shared_ptr_Promise_RequestConfig___Wrapper final {
+  public:
+    explicit Func_void_std__shared_ptr_Promise_RequestConfig___Wrapper(std::function<void(const std::shared_ptr<Promise<RequestConfig>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<Promise<RequestConfig>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::shared_ptr<Promise<RequestConfig>> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::shared_ptr<Promise<RequestConfig>>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__shared_ptr_Promise_RequestConfig__ create_Func_void_std__shared_ptr_Promise_RequestConfig__(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__shared_ptr_Promise_RequestConfig___Wrapper wrap_Func_void_std__shared_ptr_Promise_RequestConfig__(Func_void_std__shared_ptr_Promise_RequestConfig__ value) noexcept {
+    return Func_void_std__shared_ptr_Promise_RequestConfig___Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<RequestConfig>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<RequestConfig>>`.
+   */
+  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 PromiseHolder<RequestConfig> wrap_std__shared_ptr_Promise_RequestConfig__(std::shared_ptr<Promise<RequestConfig>> promise) noexcept {
+    return PromiseHolder<RequestConfig>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const RequestConfig& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const RequestConfig&)>`.
+   */
+  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::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;
+  }
+  
+  // 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<std::shared_ptr<Promise<RequestConfig>>>>(const Track& / * track * /)>>`.
+   */
+  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_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<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;
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track&)>`.
+   */
+  using Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track = std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& / * track * /)>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track_Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track_Wrapper(std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>>(std::move(func))) {}
+    inline std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>> call(Track track) const noexcept {
+      auto __result = _function->operator()(track);
+      return __result;
+    }
+  private:
+    std::unique_ptr<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const Track& /* track */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track_Wrapper wrap_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track(Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track value) noexcept {
+    return Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____Track_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<ArtworkRequestConfig>
+  /**
+   * Specialized version of `std::optional<ArtworkRequestConfig>`.
+   */
+  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_ArtworkRequestConfig_(const std::optional<ArtworkRequestConfig>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ArtworkRequestConfig get_std__optional_ArtworkRequestConfig_(const std::optional<ArtworkRequestConfig>& optional) noexcept {
+    return *optional;
+  }
+  
+  // 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<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& / * params * /)>>`.
+   */
+  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_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<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;
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams&)>`.
+   */
+  using Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____MediaTransformParams = std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& / * params * /)>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____MediaTransformParams_Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____MediaTransformParams_Wrapper(std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>>(std::move(func))) {}
+    inline std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>> call(MediaTransformParams params) const noexcept {
+      auto __result = _function->operator()(params);
+      return __result;
+    }
+  private:
+    std::unique_ptr<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<RequestConfig>>>>(const MediaTransformParams& /* params */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____MediaTransformParams create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____MediaTransformParams(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____MediaTransformParams_Wrapper wrap_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____MediaTransformParams(Func_std__shared_ptr_Promise_std__shared_ptr_Promise_RequestConfig_____MediaTransformParams value) noexcept {
+    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;
+  }
+  
+  // pragma MARK: std::optional<ImageQueryParams>
+  /**
+   * Specialized version of `std::optional<ImageQueryParams>`.
+   */
+  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_ImageQueryParams_(const std::optional<ImageQueryParams>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline ImageQueryParams get_std__optional_ImageQueryParams_(const std::optional<ImageQueryParams>& optional) noexcept {
+    return *optional;
+  }
+  
+  // 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::vector<NativeRouteEntry> get_std__optional_std__vector_NativeRouteEntry__(const std::optional<std::vector<NativeRouteEntry>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // 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::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& /* param */)>>
+  /**
+   * Specialized version of `std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& / * param * /)>>`.
+   */
+  using std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______const_BrowserSourceCallbackParam_____param______ = std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& /* param */)>>;
+  inline std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& /* param */)>> create_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______const_BrowserSourceCallbackParam_____param______(const std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& /* param */)>& value) noexcept {
+    return std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& /* param */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______const_BrowserSourceCallbackParam_____param______(const std::optional<std::function<std::shared_ptr<Promise<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::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& /* param */)> get_std__optional_std__function_std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______const_BrowserSourceCallbackParam_____param______(const std::optional<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& /* param */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& /* param */)>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam&)>`.
+   */
+  using Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______BrowserSourceCallbackParam = std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& /* param */)>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& / * param * /)>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______BrowserSourceCallbackParam_Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______BrowserSourceCallbackParam_Wrapper(std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& /* param */)>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& /* param */)>>(std::move(func))) {}
+    inline std::shared_ptr<Promise<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::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>(const BrowserSourceCallbackParam& /* param */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______BrowserSourceCallbackParam create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______BrowserSourceCallbackParam(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______BrowserSourceCallbackParam_Wrapper wrap_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______BrowserSourceCallbackParam(Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______BrowserSourceCallbackParam value) noexcept {
+    return Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError______BrowserSourceCallbackParam_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>`.
+   */
+  using std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_____ = std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>> create_std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_____() noexcept {
+    return Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>::create();
+  }
+  inline PromiseHolder<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>> wrap_std__shared_ptr_Promise_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError_____(std::shared_ptr<Promise<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>> promise) noexcept {
+    return PromiseHolder<std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>&)>`.
+   */
+  using Func_void_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError___ = std::function<void(const std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError____Wrapper final {
+  public:
+    explicit Func_void_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError____Wrapper(std::function<void(const std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::shared_ptr<Promise<std::variant<ResolvedTrack, BrowseError>>>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError___ create_Func_void_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError___(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError____Wrapper wrap_Func_void_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError___(Func_void_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError___ value) noexcept {
+    return Func_void_std__shared_ptr_Promise_std__variant_ResolvedTrack__BrowseError____Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: 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>>>;
+  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>> 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>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::variant<ResolvedTrack, BrowseError>&)>`.
+   */
+  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>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_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 {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const 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));
+  }
+  
+  // pragma MARK: std::variant<ResolvedTrack, BrowseError>
+  /**
+   * 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.
+   */
+  struct std__variant_ResolvedTrack__BrowseError_ {
+    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);
+  }
+  inline std__variant_ResolvedTrack__BrowseError_ create_std__variant_ResolvedTrack__BrowseError_(const BrowseError& value) noexcept {
+    return std__variant_ResolvedTrack__BrowseError_(value);
+  }
+  
+  // 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<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& / * params * /)>>`.
+   */
+  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_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 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;
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams&)>`.
+   */
+  using Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______SearchParams = std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& / * params * /)>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______SearchParams_Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______SearchParams_Wrapper(std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>>(std::move(func))) {}
+    inline std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>> call(SearchParams params) const noexcept {
+      auto __result = _function->operator()(params);
+      return __result;
+    }
+  private:
+    std::unique_ptr<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>(const SearchParams& /* params */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______SearchParams create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______SearchParams(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______SearchParams_Wrapper wrap_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______SearchParams(Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______SearchParams value) noexcept {
+    return Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track______SearchParams_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>`.
+   */
+  using std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track_____ = std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>> create_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track_____() noexcept {
+    return Promise<std::shared_ptr<Promise<std::vector<Track>>>>::create();
+  }
+  inline PromiseHolder<std::shared_ptr<Promise<std::vector<Track>>>> wrap_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_Track_____(std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<Track>>>>> promise) noexcept {
+    return PromiseHolder<std::shared_ptr<Promise<std::vector<Track>>>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<Promise<std::vector<Track>>>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::shared_ptr<Promise<std::vector<Track>>>&)>`.
+   */
+  using Func_void_std__shared_ptr_Promise_std__vector_Track___ = std::function<void(const std::shared_ptr<Promise<std::vector<Track>>>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::shared_ptr<Promise<std::vector<Track>>>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__shared_ptr_Promise_std__vector_Track____Wrapper final {
+  public:
+    explicit Func_void_std__shared_ptr_Promise_std__vector_Track____Wrapper(std::function<void(const std::shared_ptr<Promise<std::vector<Track>>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<Promise<std::vector<Track>>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::shared_ptr<Promise<std::vector<Track>>> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::shared_ptr<Promise<std::vector<Track>>>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__shared_ptr_Promise_std__vector_Track___ create_Func_void_std__shared_ptr_Promise_std__vector_Track___(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__shared_ptr_Promise_std__vector_Track____Wrapper wrap_Func_void_std__shared_ptr_Promise_std__vector_Track___(Func_void_std__shared_ptr_Promise_std__vector_Track___ value) noexcept {
+    return Func_void_std__shared_ptr_Promise_std__vector_Track____Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<SearchMode>
+  /**
+   * Specialized version of `std::optional<SearchMode>`.
+   */
+  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_SearchMode_(const std::optional<SearchMode>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline SearchMode get_std__optional_SearchMode_(const std::optional<SearchMode>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<std::vector<CarPlayNowPlayingButton>>
+  /**
+   * Specialized version of `std::optional<std::vector<CarPlayNowPlayingButton>>`.
+   */
+  using std__optional_std__vector_CarPlayNowPlayingButton__ = std::optional<std::vector<CarPlayNowPlayingButton>>;
+  inline std::optional<std::vector<CarPlayNowPlayingButton>> create_std__optional_std__vector_CarPlayNowPlayingButton__(const std::vector<CarPlayNowPlayingButton>& value) noexcept {
+    return std::optional<std::vector<CarPlayNowPlayingButton>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_CarPlayNowPlayingButton__(const std::optional<std::vector<CarPlayNowPlayingButton>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<CarPlayNowPlayingButton> get_std__optional_std__vector_CarPlayNowPlayingButton__(const std::optional<std::vector<CarPlayNowPlayingButton>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::vector<CarPlayNowPlayingButton>
+  /**
+   * Specialized version of `std::vector<CarPlayNowPlayingButton>`.
+   */
+  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;
+  }
+  
+  // 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;
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams&)>`.
+   */
+  using Func_std__shared_ptr_Promise_std__optional_FormattedNavigationError____FormatNavigationErrorParams = std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& / * params * /)>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__optional_FormattedNavigationError____FormatNavigationErrorParams_Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_std__optional_FormattedNavigationError____FormatNavigationErrorParams_Wrapper(std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>>(std::move(func))) {}
+    inline std::shared_ptr<Promise<std::optional<FormattedNavigationError>>> call(FormatNavigationErrorParams params) const noexcept {
+      auto __result = _function->operator()(params);
+      return __result;
+    }
+  private:
+    std::unique_ptr<std::function<std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>(const FormatNavigationErrorParams& /* params */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_std__shared_ptr_Promise_std__optional_FormattedNavigationError____FormatNavigationErrorParams create_Func_std__shared_ptr_Promise_std__optional_FormattedNavigationError____FormatNavigationErrorParams(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_std__shared_ptr_Promise_std__optional_FormattedNavigationError____FormatNavigationErrorParams_Wrapper wrap_Func_std__shared_ptr_Promise_std__optional_FormattedNavigationError____FormatNavigationErrorParams(Func_std__shared_ptr_Promise_std__optional_FormattedNavigationError____FormatNavigationErrorParams value) noexcept {
+    return Func_std__shared_ptr_Promise_std__optional_FormattedNavigationError____FormatNavigationErrorParams_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>`.
+   */
+  using std__shared_ptr_Promise_std__optional_FormattedNavigationError___ = std::shared_ptr<Promise<std::optional<FormattedNavigationError>>>;
+  inline std::shared_ptr<Promise<std::optional<FormattedNavigationError>>> create_std__shared_ptr_Promise_std__optional_FormattedNavigationError___() noexcept {
+    return Promise<std::optional<FormattedNavigationError>>::create();
+  }
+  inline PromiseHolder<std::optional<FormattedNavigationError>> wrap_std__shared_ptr_Promise_std__optional_FormattedNavigationError___(std::shared_ptr<Promise<std::optional<FormattedNavigationError>>> promise) noexcept {
+    return PromiseHolder<std::optional<FormattedNavigationError>>(std::move(promise));
+  }
+  
+  // 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::optional<PartialAndroidSetupPlayerOptions>
+  /**
+   * Specialized version of `std::optional<PartialAndroidSetupPlayerOptions>`.
+   */
+  using std__optional_PartialAndroidSetupPlayerOptions_ = std::optional<PartialAndroidSetupPlayerOptions>;
+  inline std::optional<PartialAndroidSetupPlayerOptions> create_std__optional_PartialAndroidSetupPlayerOptions_(const PartialAndroidSetupPlayerOptions& value) noexcept {
+    return std::optional<PartialAndroidSetupPlayerOptions>(value);
+  }
+  inline bool has_value_std__optional_PartialAndroidSetupPlayerOptions_(const std::optional<PartialAndroidSetupPlayerOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline PartialAndroidSetupPlayerOptions get_std__optional_PartialAndroidSetupPlayerOptions_(const std::optional<PartialAndroidSetupPlayerOptions>& optional) noexcept {
+    return *optional;
+  }
+  
+  // 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;
+  }
+  
+  // pragma MARK: std::variant<bool, AndroidAudioOffloadSettings>
+  /**
+   * Wrapper struct for `std::variant<bool, AndroidAudioOffloadSettings>`.
+   * 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__AndroidAudioOffloadSettings_ {
+    std::variant<bool, AndroidAudioOffloadSettings> variant;
+    std__variant_bool__AndroidAudioOffloadSettings_(std::variant<bool, AndroidAudioOffloadSettings> variant): variant(variant) { }
+    operator std::variant<bool, AndroidAudioOffloadSettings>() 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 AndroidAudioOffloadSettings get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_bool__AndroidAudioOffloadSettings_ create_std__variant_bool__AndroidAudioOffloadSettings_(bool value) noexcept {
+    return std__variant_bool__AndroidAudioOffloadSettings_(value);
+  }
+  inline std__variant_bool__AndroidAudioOffloadSettings_ create_std__variant_bool__AndroidAudioOffloadSettings_(const AndroidAudioOffloadSettings& value) noexcept {
+    return std__variant_bool__AndroidAudioOffloadSettings_(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;
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, double>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, double>`.
+   * 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__double_ {
+    std::variant<nitro::NullType, double> variant;
+    std__variant_nitro__NullType__double_(std::variant<nitro::NullType, double> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, double>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline double get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__double_ create_std__variant_nitro__NullType__double_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__double_(value);
+  }
+  inline std__variant_nitro__NullType__double_ create_std__variant_nitro__NullType__double_(double value) noexcept {
+    return std__variant_nitro__NullType__double_(value);
+  }
+  
+  // pragma MARK: std::optional<AndroidAudioContentType>
+  /**
+   * Specialized version of `std::optional<AndroidAudioContentType>`.
+   */
+  using std__optional_AndroidAudioContentType_ = std::optional<AndroidAudioContentType>;
+  inline std::optional<AndroidAudioContentType> create_std__optional_AndroidAudioContentType_(const AndroidAudioContentType& value) noexcept {
+    return std::optional<AndroidAudioContentType>(value);
+  }
+  inline bool has_value_std__optional_AndroidAudioContentType_(const std::optional<AndroidAudioContentType>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline AndroidAudioContentType get_std__optional_AndroidAudioContentType_(const std::optional<AndroidAudioContentType>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<AndroidPlayerWakeMode>
+  /**
+   * Specialized version of `std::optional<AndroidPlayerWakeMode>`.
+   */
+  using std__optional_AndroidPlayerWakeMode_ = std::optional<AndroidPlayerWakeMode>;
+  inline std::optional<AndroidPlayerWakeMode> create_std__optional_AndroidPlayerWakeMode_(const AndroidPlayerWakeMode& value) noexcept {
+    return std::optional<AndroidPlayerWakeMode>(value);
+  }
+  inline bool has_value_std__optional_AndroidPlayerWakeMode_(const std::optional<AndroidPlayerWakeMode>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline AndroidPlayerWakeMode get_std__optional_AndroidPlayerWakeMode_(const std::optional<AndroidPlayerWakeMode>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<PartialIOSSetupPlayerOptions>
+  /**
+   * Specialized version of `std::optional<PartialIOSSetupPlayerOptions>`.
+   */
+  using std__optional_PartialIOSSetupPlayerOptions_ = std::optional<PartialIOSSetupPlayerOptions>;
+  inline std::optional<PartialIOSSetupPlayerOptions> create_std__optional_PartialIOSSetupPlayerOptions_(const PartialIOSSetupPlayerOptions& value) noexcept {
+    return std::optional<PartialIOSSetupPlayerOptions>(value);
+  }
+  inline bool has_value_std__optional_PartialIOSSetupPlayerOptions_(const std::optional<PartialIOSSetupPlayerOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline PartialIOSSetupPlayerOptions get_std__optional_PartialIOSSetupPlayerOptions_(const std::optional<PartialIOSSetupPlayerOptions>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<IOSCategory>
+  /**
+   * Specialized version of `std::optional<IOSCategory>`.
+   */
+  using std__optional_IOSCategory_ = std::optional<IOSCategory>;
+  inline std::optional<IOSCategory> create_std__optional_IOSCategory_(const IOSCategory& value) noexcept {
+    return std::optional<IOSCategory>(value);
+  }
+  inline bool has_value_std__optional_IOSCategory_(const std::optional<IOSCategory>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline IOSCategory get_std__optional_IOSCategory_(const std::optional<IOSCategory>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<IOSCategoryMode>
+  /**
+   * Specialized version of `std::optional<IOSCategoryMode>`.
+   */
+  using std__optional_IOSCategoryMode_ = std::optional<IOSCategoryMode>;
+  inline std::optional<IOSCategoryMode> create_std__optional_IOSCategoryMode_(const IOSCategoryMode& value) noexcept {
+    return std::optional<IOSCategoryMode>(value);
+  }
+  inline bool has_value_std__optional_IOSCategoryMode_(const std::optional<IOSCategoryMode>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline IOSCategoryMode get_std__optional_IOSCategoryMode_(const std::optional<IOSCategoryMode>& optional) noexcept {
+    return *optional;
+  }
+  
+  // 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;
+  }
+  
+  // pragma MARK: std::vector<IOSCategoryOptions>
+  /**
+   * Specialized version of `std::vector<IOSCategoryOptions>`.
+   */
+  using std__vector_IOSCategoryOptions_ = std::vector<IOSCategoryOptions>;
+  inline std::vector<IOSCategoryOptions> create_std__vector_IOSCategoryOptions_(size_t size) noexcept {
+    std::vector<IOSCategoryOptions> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<IOSCategoryPolicy>
+  /**
+   * Specialized version of `std::optional<IOSCategoryPolicy>`.
+   */
+  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_IOSCategoryPolicy_(const std::optional<IOSCategoryPolicy>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline IOSCategoryPolicy get_std__optional_IOSCategoryPolicy_(const std::optional<IOSCategoryPolicy>& optional) noexcept {
+    return *optional;
+  }
+  
+  // 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;
+  }
+  
+  // pragma MARK: std::variant<bool, RetryConfig>
+  /**
+   * Wrapper struct for `std::variant<bool, RetryConfig>`.
+   * 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__RetryConfig_ {
+    std::variant<bool, RetryConfig> variant;
+    std__variant_bool__RetryConfig_(std::variant<bool, RetryConfig> variant): variant(variant) { }
+    operator std::variant<bool, RetryConfig>() 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 RetryConfig get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_bool__RetryConfig_ create_std__variant_bool__RetryConfig_(bool value) noexcept {
+    return std__variant_bool__RetryConfig_(value);
+  }
+  inline std__variant_bool__RetryConfig_ create_std__variant_bool__RetryConfig_(const RetryConfig& value) noexcept {
+    return std__variant_bool__RetryConfig_(value);
+  }
+  
+  // pragma MARK: std::optional<NitroAndroidUpdateOptions>
+  /**
+   * Specialized version of `std::optional<NitroAndroidUpdateOptions>`.
+   */
+  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_NitroAndroidUpdateOptions_(const std::optional<NitroAndroidUpdateOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline NitroAndroidUpdateOptions get_std__optional_NitroAndroidUpdateOptions_(const std::optional<NitroAndroidUpdateOptions>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<AppKilledPlaybackBehavior>
+  /**
+   * Specialized version of `std::optional<AppKilledPlaybackBehavior>`.
+   */
+  using std__optional_AppKilledPlaybackBehavior_ = std::optional<AppKilledPlaybackBehavior>;
+  inline std::optional<AppKilledPlaybackBehavior> create_std__optional_AppKilledPlaybackBehavior_(const AppKilledPlaybackBehavior& value) noexcept {
+    return std::optional<AppKilledPlaybackBehavior>(value);
+  }
+  inline bool has_value_std__optional_AppKilledPlaybackBehavior_(const std::optional<AppKilledPlaybackBehavior>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline AppKilledPlaybackBehavior get_std__optional_AppKilledPlaybackBehavior_(const std::optional<AppKilledPlaybackBehavior>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<RatingType>
+  /**
+   * Specialized version of `std::optional<RatingType>`.
+   */
+  using std__optional_RatingType_ = std::optional<RatingType>;
+  inline std::optional<RatingType> create_std__optional_RatingType_(const RatingType& value) noexcept {
+    return std::optional<RatingType>(value);
+  }
+  inline bool has_value_std__optional_RatingType_(const std::optional<RatingType>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline RatingType get_std__optional_RatingType_(const std::optional<RatingType>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NotificationButtonLayout>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NotificationButtonLayout>>`.
+   */
+  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);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NotificationButtonLayout__(const std::optional<std::variant<nitro::NullType, NotificationButtonLayout>>& 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 {
+    return *optional;
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, NotificationButtonLayout>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NotificationButtonLayout>`.
+   * 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_ {
+    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 {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline NotificationButtonLayout 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__NotificationButtonLayout_ create_std__variant_nitro__NullType__NotificationButtonLayout_(const NotificationButtonLayout& value) noexcept {
+    return std__variant_nitro__NullType__NotificationButtonLayout_(value);
+  }
+  
+  // pragma MARK: std::optional<NotificationButton>
+  /**
+   * Specialized version of `std::optional<NotificationButton>`.
+   */
+  using std__optional_NotificationButton_ = std::optional<NotificationButton>;
+  inline std::optional<NotificationButton> create_std__optional_NotificationButton_(const NotificationButton& value) noexcept {
+    return std::optional<NotificationButton>(value);
+  }
+  inline bool has_value_std__optional_NotificationButton_(const std::optional<NotificationButton>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline NotificationButton get_std__optional_NotificationButton_(const std::optional<NotificationButton>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<std::vector<NotificationButton>>
+  /**
+   * Specialized version of `std::optional<std::vector<NotificationButton>>`.
+   */
+  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;
+  }
+  
+  // 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;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<PlayerCapabilities>
+  /**
+   * Specialized version of `std::optional<PlayerCapabilities>`.
+   */
+  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_PlayerCapabilities_(const std::optional<PlayerCapabilities>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline PlayerCapabilities get_std__optional_PlayerCapabilities_(const std::optional<PlayerCapabilities>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<std::vector<double>>
+  /**
+   * Specialized version of `std::optional<std::vector<double>>`.
+   */
+  using std__optional_std__vector_double__ = std::optional<std::vector<double>>;
+  inline std::optional<std::vector<double>> create_std__optional_std__vector_double__(const std::vector<double>& value) noexcept {
+    return std::optional<std::vector<double>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_double__(const std::optional<std::vector<double>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<double> get_std__optional_std__vector_double__(const std::optional<std::vector<double>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::vector<double>
+  /**
+   * Specialized version of `std::vector<double>`.
+   */
+  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<AndroidUpdateOptions>
+  /**
+   * Specialized version of `std::optional<AndroidUpdateOptions>`.
+   */
+  using std__optional_AndroidUpdateOptions_ = std::optional<AndroidUpdateOptions>;
+  inline std::optional<AndroidUpdateOptions> create_std__optional_AndroidUpdateOptions_(const AndroidUpdateOptions& value) noexcept {
+    return std::optional<AndroidUpdateOptions>(value);
+  }
+  inline bool has_value_std__optional_AndroidUpdateOptions_(const std::optional<AndroidUpdateOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline AndroidUpdateOptions get_std__optional_AndroidUpdateOptions_(const std::optional<AndroidUpdateOptions>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::vector<ChapterMetadata>
+  /**
+   * Specialized version of `std::vector<ChapterMetadata>`.
+   */
+  using std__vector_ChapterMetadata_ = std::vector<ChapterMetadata>;
+  inline std::vector<ChapterMetadata> create_std__vector_ChapterMetadata_(size_t size) noexcept {
+    std::vector<ChapterMetadata> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<ChapterMetadata>& /* chapters */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<ChapterMetadata>&)>`.
+   */
+  using Func_void_std__vector_ChapterMetadata_ = std::function<void(const std::vector<ChapterMetadata>& /* chapters */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<ChapterMetadata>& / * chapters * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_ChapterMetadata__Wrapper final {
+  public:
+    explicit Func_void_std__vector_ChapterMetadata__Wrapper(std::function<void(const std::vector<ChapterMetadata>& /* chapters */)>&& func): _function(std::make_unique<std::function<void(const std::vector<ChapterMetadata>& /* chapters */)>>(std::move(func))) {}
+    inline void call(std::vector<ChapterMetadata> chapters) const noexcept {
+      _function->operator()(chapters);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<ChapterMetadata>& /* chapters */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_ChapterMetadata_ create_Func_void_std__vector_ChapterMetadata_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_ChapterMetadata__Wrapper wrap_Func_void_std__vector_ChapterMetadata_(Func_void_std__vector_ChapterMetadata_ value) noexcept {
+    return Func_void_std__vector_ChapterMetadata__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const TrackMetadata& /* metadata */)>
+  /**
+   * Specialized version of `std::function<void(const TrackMetadata&)>`.
+   */
+  using Func_void_TrackMetadata = std::function<void(const TrackMetadata& /* metadata */)>;
+  /**
+   * Wrapper class for a `std::function<void(const TrackMetadata& / * metadata * /)>`, this can be used from Swift.
+   */
+  class Func_void_TrackMetadata_Wrapper final {
+  public:
+    explicit Func_void_TrackMetadata_Wrapper(std::function<void(const TrackMetadata& /* metadata */)>&& func): _function(std::make_unique<std::function<void(const TrackMetadata& /* metadata */)>>(std::move(func))) {}
+    inline void call(TrackMetadata metadata) const noexcept {
+      _function->operator()(metadata);
+    }
+  private:
+    std::unique_ptr<std::function<void(const TrackMetadata& /* metadata */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_TrackMetadata create_Func_void_TrackMetadata(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_TrackMetadata_Wrapper wrap_Func_void_TrackMetadata(Func_void_TrackMetadata value) noexcept {
+    return Func_void_TrackMetadata_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const TimedMetadata& /* metadata */)>
+  /**
+   * Specialized version of `std::function<void(const TimedMetadata&)>`.
+   */
+  using Func_void_TimedMetadata = std::function<void(const TimedMetadata& /* metadata */)>;
+  /**
+   * Wrapper class for a `std::function<void(const TimedMetadata& / * metadata * /)>`, this can be used from Swift.
+   */
+  class Func_void_TimedMetadata_Wrapper final {
+  public:
+    explicit Func_void_TimedMetadata_Wrapper(std::function<void(const TimedMetadata& /* metadata */)>&& func): _function(std::make_unique<std::function<void(const TimedMetadata& /* metadata */)>>(std::move(func))) {}
+    inline void call(TimedMetadata metadata) const noexcept {
+      _function->operator()(metadata);
+    }
+  private:
+    std::unique_ptr<std::function<void(const TimedMetadata& /* metadata */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_TimedMetadata create_Func_void_TimedMetadata(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_TimedMetadata_Wrapper wrap_Func_void_TimedMetadata(Func_void_TimedMetadata value) noexcept {
+    return Func_void_TimedMetadata_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<Track>
+  /**
+   * Specialized version of `std::optional<Track>`.
+   */
+  using std__optional_Track_ = std::optional<Track>;
+  inline std::optional<Track> create_std__optional_Track_(const Track& value) noexcept {
+    return std::optional<Track>(value);
+  }
+  inline bool has_value_std__optional_Track_(const std::optional<Track>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline Track get_std__optional_Track_(const std::optional<Track>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const PlaybackActiveTrackChangedEvent& /* data */)>
+  /**
+   * Specialized version of `std::function<void(const PlaybackActiveTrackChangedEvent&)>`.
+   */
+  using Func_void_PlaybackActiveTrackChangedEvent = std::function<void(const PlaybackActiveTrackChangedEvent& /* data */)>;
+  /**
+   * Wrapper class for a `std::function<void(const PlaybackActiveTrackChangedEvent& / * data * /)>`, this can be used from Swift.
+   */
+  class Func_void_PlaybackActiveTrackChangedEvent_Wrapper final {
+  public:
+    explicit Func_void_PlaybackActiveTrackChangedEvent_Wrapper(std::function<void(const PlaybackActiveTrackChangedEvent& /* data */)>&& func): _function(std::make_unique<std::function<void(const PlaybackActiveTrackChangedEvent& /* data */)>>(std::move(func))) {}
+    inline void call(PlaybackActiveTrackChangedEvent data) const noexcept {
+      _function->operator()(data);
+    }
+  private:
+    std::unique_ptr<std::function<void(const PlaybackActiveTrackChangedEvent& /* data */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_PlaybackActiveTrackChangedEvent create_Func_void_PlaybackActiveTrackChangedEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_PlaybackActiveTrackChangedEvent_Wrapper wrap_Func_void_PlaybackActiveTrackChangedEvent(Func_void_PlaybackActiveTrackChangedEvent value) noexcept {
+    return Func_void_PlaybackActiveTrackChangedEvent_Wrapper(std::move(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;
+  }
+  
+  // pragma MARK: std::function<void(const PlaybackErrorEvent& /* data */)>
+  /**
+   * Specialized version of `std::function<void(const PlaybackErrorEvent&)>`.
+   */
+  using Func_void_PlaybackErrorEvent = std::function<void(const PlaybackErrorEvent& /* data */)>;
+  /**
+   * Wrapper class for a `std::function<void(const PlaybackErrorEvent& / * data * /)>`, this can be used from Swift.
+   */
+  class Func_void_PlaybackErrorEvent_Wrapper final {
+  public:
+    explicit Func_void_PlaybackErrorEvent_Wrapper(std::function<void(const PlaybackErrorEvent& /* data */)>&& func): _function(std::make_unique<std::function<void(const PlaybackErrorEvent& /* data */)>>(std::move(func))) {}
+    inline void call(PlaybackErrorEvent data) const noexcept {
+      _function->operator()(data);
+    }
+  private:
+    std::unique_ptr<std::function<void(const PlaybackErrorEvent& /* data */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_PlaybackErrorEvent create_Func_void_PlaybackErrorEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_PlaybackErrorEvent_Wrapper wrap_Func_void_PlaybackErrorEvent(Func_void_PlaybackErrorEvent value) noexcept {
+    return Func_void_PlaybackErrorEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const PlaybackPlayWhenReadyChangedEvent& /* data */)>
+  /**
+   * Specialized version of `std::function<void(const PlaybackPlayWhenReadyChangedEvent&)>`.
+   */
+  using Func_void_PlaybackPlayWhenReadyChangedEvent = std::function<void(const PlaybackPlayWhenReadyChangedEvent& /* data */)>;
+  /**
+   * Wrapper class for a `std::function<void(const PlaybackPlayWhenReadyChangedEvent& / * data * /)>`, this can be used from Swift.
+   */
+  class Func_void_PlaybackPlayWhenReadyChangedEvent_Wrapper final {
+  public:
+    explicit Func_void_PlaybackPlayWhenReadyChangedEvent_Wrapper(std::function<void(const PlaybackPlayWhenReadyChangedEvent& /* data */)>&& func): _function(std::make_unique<std::function<void(const PlaybackPlayWhenReadyChangedEvent& /* data */)>>(std::move(func))) {}
+    inline void call(PlaybackPlayWhenReadyChangedEvent data) const noexcept {
+      _function->operator()(data);
+    }
+  private:
+    std::unique_ptr<std::function<void(const PlaybackPlayWhenReadyChangedEvent& /* data */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_PlaybackPlayWhenReadyChangedEvent create_Func_void_PlaybackPlayWhenReadyChangedEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_PlaybackPlayWhenReadyChangedEvent_Wrapper wrap_Func_void_PlaybackPlayWhenReadyChangedEvent(Func_void_PlaybackPlayWhenReadyChangedEvent value) noexcept {
+    return Func_void_PlaybackPlayWhenReadyChangedEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const PlayingState& /* data */)>
+  /**
+   * Specialized version of `std::function<void(const PlayingState&)>`.
+   */
+  using Func_void_PlayingState = std::function<void(const PlayingState& /* data */)>;
+  /**
+   * Wrapper class for a `std::function<void(const PlayingState& / * data * /)>`, this can be used from Swift.
+   */
+  class Func_void_PlayingState_Wrapper final {
+  public:
+    explicit Func_void_PlayingState_Wrapper(std::function<void(const PlayingState& /* data */)>&& func): _function(std::make_unique<std::function<void(const PlayingState& /* data */)>>(std::move(func))) {}
+    inline void call(PlayingState data) const noexcept {
+      _function->operator()(data);
+    }
+  private:
+    std::unique_ptr<std::function<void(const PlayingState& /* data */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_PlayingState create_Func_void_PlayingState(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_PlayingState_Wrapper wrap_Func_void_PlayingState(Func_void_PlayingState value) noexcept {
+    return Func_void_PlayingState_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const PlaybackProgressUpdatedEvent& /* data */)>
+  /**
+   * Specialized version of `std::function<void(const PlaybackProgressUpdatedEvent&)>`.
+   */
+  using Func_void_PlaybackProgressUpdatedEvent = std::function<void(const PlaybackProgressUpdatedEvent& /* data */)>;
+  /**
+   * Wrapper class for a `std::function<void(const PlaybackProgressUpdatedEvent& / * data * /)>`, this can be used from Swift.
+   */
+  class Func_void_PlaybackProgressUpdatedEvent_Wrapper final {
+  public:
+    explicit Func_void_PlaybackProgressUpdatedEvent_Wrapper(std::function<void(const PlaybackProgressUpdatedEvent& /* data */)>&& func): _function(std::make_unique<std::function<void(const PlaybackProgressUpdatedEvent& /* data */)>>(std::move(func))) {}
+    inline void call(PlaybackProgressUpdatedEvent data) const noexcept {
+      _function->operator()(data);
+    }
+  private:
+    std::unique_ptr<std::function<void(const PlaybackProgressUpdatedEvent& /* data */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_PlaybackProgressUpdatedEvent create_Func_void_PlaybackProgressUpdatedEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_PlaybackProgressUpdatedEvent_Wrapper wrap_Func_void_PlaybackProgressUpdatedEvent(Func_void_PlaybackProgressUpdatedEvent value) noexcept {
+    return Func_void_PlaybackProgressUpdatedEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const PlaybackQueueEndedEvent& /* data */)>
+  /**
+   * Specialized version of `std::function<void(const PlaybackQueueEndedEvent&)>`.
+   */
+  using Func_void_PlaybackQueueEndedEvent = std::function<void(const PlaybackQueueEndedEvent& /* data */)>;
+  /**
+   * Wrapper class for a `std::function<void(const PlaybackQueueEndedEvent& / * data * /)>`, this can be used from Swift.
+   */
+  class Func_void_PlaybackQueueEndedEvent_Wrapper final {
+  public:
+    explicit Func_void_PlaybackQueueEndedEvent_Wrapper(std::function<void(const PlaybackQueueEndedEvent& /* data */)>&& func): _function(std::make_unique<std::function<void(const PlaybackQueueEndedEvent& /* data */)>>(std::move(func))) {}
+    inline void call(PlaybackQueueEndedEvent data) const noexcept {
+      _function->operator()(data);
+    }
+  private:
+    std::unique_ptr<std::function<void(const PlaybackQueueEndedEvent& /* data */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_PlaybackQueueEndedEvent create_Func_void_PlaybackQueueEndedEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_PlaybackQueueEndedEvent_Wrapper wrap_Func_void_PlaybackQueueEndedEvent(Func_void_PlaybackQueueEndedEvent value) noexcept {
+    return Func_void_PlaybackQueueEndedEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const RepeatModeChangedEvent& /* data */)>
+  /**
+   * Specialized version of `std::function<void(const RepeatModeChangedEvent&)>`.
+   */
+  using Func_void_RepeatModeChangedEvent = std::function<void(const RepeatModeChangedEvent& /* data */)>;
+  /**
+   * Wrapper class for a `std::function<void(const RepeatModeChangedEvent& / * data * /)>`, this can be used from Swift.
+   */
+  class Func_void_RepeatModeChangedEvent_Wrapper final {
+  public:
+    explicit Func_void_RepeatModeChangedEvent_Wrapper(std::function<void(const RepeatModeChangedEvent& /* data */)>&& func): _function(std::make_unique<std::function<void(const RepeatModeChangedEvent& /* data */)>>(std::move(func))) {}
+    inline void call(RepeatModeChangedEvent data) const noexcept {
+      _function->operator()(data);
+    }
+  private:
+    std::unique_ptr<std::function<void(const RepeatModeChangedEvent& /* data */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_RepeatModeChangedEvent create_Func_void_RepeatModeChangedEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_RepeatModeChangedEvent_Wrapper wrap_Func_void_RepeatModeChangedEvent(Func_void_RepeatModeChangedEvent value) noexcept {
+    return Func_void_RepeatModeChangedEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(bool /* enabled */)>
+  /**
+   * Specialized version of `std::function<void(bool)>`.
+   */
+  using Func_void_bool = std::function<void(bool /* enabled */)>;
+  /**
+   * Wrapper class for a `std::function<void(bool / * enabled * /)>`, this can be used from Swift.
+   */
+  class Func_void_bool_Wrapper final {
+  public:
+    explicit Func_void_bool_Wrapper(std::function<void(bool /* enabled */)>&& func): _function(std::make_unique<std::function<void(bool /* enabled */)>>(std::move(func))) {}
+    inline void call(bool enabled) const noexcept {
+      _function->operator()(enabled);
+    }
+  private:
+    std::unique_ptr<std::function<void(bool /* enabled */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_bool create_Func_void_bool(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_bool_Wrapper wrap_Func_void_bool(Func_void_bool value) noexcept {
+    return Func_void_bool_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>`.
+   * 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__SleepTimerTime__SleepTimerEndOfTrack_ {
+    std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack> variant;
+    std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_(std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline SleepTimerTime get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+    inline SleepTimerEndOfTrack get_2() const noexcept {
+      return std::get<2>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_ create_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_(value);
+  }
+  inline std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_ create_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_(const SleepTimerTime& value) noexcept {
+    return std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_(value);
+  }
+  inline std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_ create_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_(const SleepTimerEndOfTrack& value) noexcept {
+    return std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__ = std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>;
+  inline std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>> create_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__(const std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__(const std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack> get_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__(const std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>& /* data */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>&)>`.
+   */
+  using Func_void_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__ = std::function<void(const std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>& /* data */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>& / * data * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack___Wrapper final {
+  public:
+    explicit Func_void_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack___Wrapper(std::function<void(const std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>& /* data */)>&& func): _function(std::make_unique<std::function<void(const std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>& /* data */)>>(std::move(func))) {}
+    inline void call(std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>> data) const noexcept {
+      _function->operator()(data);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>& /* data */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__ create_Func_void_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack___Wrapper wrap_Func_void_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__(Func_void_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__ value) noexcept {
+    return Func_void_std__optional_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack___Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const Playback& /* data */)>
+  /**
+   * Specialized version of `std::function<void(const Playback&)>`.
+   */
+  using Func_void_Playback = std::function<void(const Playback& /* data */)>;
+  /**
+   * Wrapper class for a `std::function<void(const Playback& / * data * /)>`, this can be used from Swift.
+   */
+  class Func_void_Playback_Wrapper final {
+  public:
+    explicit Func_void_Playback_Wrapper(std::function<void(const Playback& /* data */)>&& func): _function(std::make_unique<std::function<void(const Playback& /* data */)>>(std::move(func))) {}
+    inline void call(Playback data) const noexcept {
+      _function->operator()(data);
+    }
+  private:
+    std::unique_ptr<std::function<void(const Playback& /* data */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_Playback create_Func_void_Playback(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Playback_Wrapper wrap_Func_void_Playback(Func_void_Playback value) noexcept {
+    return Func_void_Playback_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const RemoteJumpBackwardEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const RemoteJumpBackwardEvent&)>`.
+   */
+  using Func_void_RemoteJumpBackwardEvent = std::function<void(const RemoteJumpBackwardEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const RemoteJumpBackwardEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_RemoteJumpBackwardEvent_Wrapper final {
+  public:
+    explicit Func_void_RemoteJumpBackwardEvent_Wrapper(std::function<void(const RemoteJumpBackwardEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const RemoteJumpBackwardEvent& /* event */)>>(std::move(func))) {}
+    inline void call(RemoteJumpBackwardEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const RemoteJumpBackwardEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_RemoteJumpBackwardEvent create_Func_void_RemoteJumpBackwardEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_RemoteJumpBackwardEvent_Wrapper wrap_Func_void_RemoteJumpBackwardEvent(Func_void_RemoteJumpBackwardEvent value) noexcept {
+    return Func_void_RemoteJumpBackwardEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const RemoteJumpForwardEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const RemoteJumpForwardEvent&)>`.
+   */
+  using Func_void_RemoteJumpForwardEvent = std::function<void(const RemoteJumpForwardEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const RemoteJumpForwardEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_RemoteJumpForwardEvent_Wrapper final {
+  public:
+    explicit Func_void_RemoteJumpForwardEvent_Wrapper(std::function<void(const RemoteJumpForwardEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const RemoteJumpForwardEvent& /* event */)>>(std::move(func))) {}
+    inline void call(RemoteJumpForwardEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const RemoteJumpForwardEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_RemoteJumpForwardEvent create_Func_void_RemoteJumpForwardEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_RemoteJumpForwardEvent_Wrapper wrap_Func_void_RemoteJumpForwardEvent(Func_void_RemoteJumpForwardEvent value) noexcept {
+    return Func_void_RemoteJumpForwardEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const RemotePlayIdEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const RemotePlayIdEvent&)>`.
+   */
+  using Func_void_RemotePlayIdEvent = std::function<void(const RemotePlayIdEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const RemotePlayIdEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_RemotePlayIdEvent_Wrapper final {
+  public:
+    explicit Func_void_RemotePlayIdEvent_Wrapper(std::function<void(const RemotePlayIdEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const RemotePlayIdEvent& /* event */)>>(std::move(func))) {}
+    inline void call(RemotePlayIdEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const RemotePlayIdEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_RemotePlayIdEvent create_Func_void_RemotePlayIdEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_RemotePlayIdEvent_Wrapper wrap_Func_void_RemotePlayIdEvent(Func_void_RemotePlayIdEvent value) noexcept {
+    return Func_void_RemotePlayIdEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const RemotePlaySearchEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const RemotePlaySearchEvent&)>`.
+   */
+  using Func_void_RemotePlaySearchEvent = std::function<void(const RemotePlaySearchEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const RemotePlaySearchEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_RemotePlaySearchEvent_Wrapper final {
+  public:
+    explicit Func_void_RemotePlaySearchEvent_Wrapper(std::function<void(const RemotePlaySearchEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const RemotePlaySearchEvent& /* event */)>>(std::move(func))) {}
+    inline void call(RemotePlaySearchEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const RemotePlaySearchEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_RemotePlaySearchEvent create_Func_void_RemotePlaySearchEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_RemotePlaySearchEvent_Wrapper wrap_Func_void_RemotePlaySearchEvent(Func_void_RemotePlaySearchEvent value) noexcept {
+    return Func_void_RemotePlaySearchEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const RemoteSeekEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const RemoteSeekEvent&)>`.
+   */
+  using Func_void_RemoteSeekEvent = std::function<void(const RemoteSeekEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const RemoteSeekEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_RemoteSeekEvent_Wrapper final {
+  public:
+    explicit Func_void_RemoteSeekEvent_Wrapper(std::function<void(const RemoteSeekEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const RemoteSeekEvent& /* event */)>>(std::move(func))) {}
+    inline void call(RemoteSeekEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const RemoteSeekEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_RemoteSeekEvent create_Func_void_RemoteSeekEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_RemoteSeekEvent_Wrapper wrap_Func_void_RemoteSeekEvent(Func_void_RemoteSeekEvent value) noexcept {
+    return Func_void_RemoteSeekEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating>
+  /**
+   * Wrapper struct for `std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating>`.
+   * 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_HeartRating__ThumbsRating__StarRating__PercentageRating_ {
+    std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating> variant;
+    std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating_(std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating> variant): variant(variant) { }
+    operator std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline HeartRating get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline ThumbsRating get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+    inline StarRating get_2() const noexcept {
+      return std::get<2>(variant);
+    }
+    inline PercentageRating get_3() const noexcept {
+      return std::get<3>(variant);
+    }
+  };
+  inline std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating_ create_std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating_(const HeartRating& value) noexcept {
+    return std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating_(value);
+  }
+  inline std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating_ create_std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating_(const ThumbsRating& value) noexcept {
+    return std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating_(value);
+  }
+  inline std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating_ create_std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating_(const StarRating& value) noexcept {
+    return std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating_(value);
+  }
+  inline std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating_ create_std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating_(const PercentageRating& value) noexcept {
+    return std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating_(value);
+  }
+  
+  // pragma MARK: std::function<void(const RemoteSetRatingEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const RemoteSetRatingEvent&)>`.
+   */
+  using Func_void_RemoteSetRatingEvent = std::function<void(const RemoteSetRatingEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const RemoteSetRatingEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_RemoteSetRatingEvent_Wrapper final {
+  public:
+    explicit Func_void_RemoteSetRatingEvent_Wrapper(std::function<void(const RemoteSetRatingEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const RemoteSetRatingEvent& /* event */)>>(std::move(func))) {}
+    inline void call(RemoteSetRatingEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const RemoteSetRatingEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_RemoteSetRatingEvent create_Func_void_RemoteSetRatingEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_RemoteSetRatingEvent_Wrapper wrap_Func_void_RemoteSetRatingEvent(Func_void_RemoteSetRatingEvent value) noexcept {
+    return Func_void_RemoteSetRatingEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const RemoteSkipEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const RemoteSkipEvent&)>`.
+   */
+  using Func_void_RemoteSkipEvent = std::function<void(const RemoteSkipEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const RemoteSkipEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_RemoteSkipEvent_Wrapper final {
+  public:
+    explicit Func_void_RemoteSkipEvent_Wrapper(std::function<void(const RemoteSkipEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const RemoteSkipEvent& /* event */)>>(std::move(func))) {}
+    inline void call(RemoteSkipEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const RemoteSkipEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_RemoteSkipEvent create_Func_void_RemoteSkipEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_RemoteSkipEvent_Wrapper wrap_Func_void_RemoteSkipEvent(Func_void_RemoteSkipEvent value) noexcept {
+    return Func_void_RemoteSkipEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<AndroidOptions>
+  /**
+   * Specialized version of `std::optional<AndroidOptions>`.
+   */
+  using std__optional_AndroidOptions_ = std::optional<AndroidOptions>;
+  inline std::optional<AndroidOptions> create_std__optional_AndroidOptions_(const AndroidOptions& value) noexcept {
+    return std::optional<AndroidOptions>(value);
+  }
+  inline bool has_value_std__optional_AndroidOptions_(const std::optional<AndroidOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline AndroidOptions get_std__optional_AndroidOptions_(const std::optional<AndroidOptions>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const Options& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const Options&)>`.
+   */
+  using Func_void_Options = std::function<void(const Options& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const Options& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_Options_Wrapper final {
+  public:
+    explicit Func_void_Options_Wrapper(std::function<void(const Options& /* event */)>&& func): _function(std::make_unique<std::function<void(const Options& /* event */)>>(std::move(func))) {}
+    inline void call(Options event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const Options& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_Options create_Func_void_Options(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Options_Wrapper wrap_Func_void_Options(Func_void_Options value) noexcept {
+    return Func_void_Options_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const FavoriteChangedEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const FavoriteChangedEvent&)>`.
+   */
+  using Func_void_FavoriteChangedEvent = std::function<void(const FavoriteChangedEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const FavoriteChangedEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_FavoriteChangedEvent_Wrapper final {
+  public:
+    explicit Func_void_FavoriteChangedEvent_Wrapper(std::function<void(const FavoriteChangedEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const FavoriteChangedEvent& /* event */)>>(std::move(func))) {}
+    inline void call(FavoriteChangedEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const FavoriteChangedEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_FavoriteChangedEvent create_Func_void_FavoriteChangedEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_FavoriteChangedEvent_Wrapper wrap_Func_void_FavoriteChangedEvent(Func_void_FavoriteChangedEvent value) noexcept {
+    return Func_void_FavoriteChangedEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating>>
+  /**
+   * Specialized version of `std::optional<std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating>>`.
+   */
+  using std__optional_std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating__ = std::optional<std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating>>;
+  inline std::optional<std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating>> create_std__optional_std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating__(const std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating>& value) noexcept {
+    return std::optional<std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating__(const std::optional<std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating> get_std__optional_std__variant_HeartRating__ThumbsRating__StarRating__PercentageRating__(const std::optional<std::variant<HeartRating, ThumbsRating, StarRating, PercentageRating>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const NowPlayingMetadata& /* metadata */)>
+  /**
+   * Specialized version of `std::function<void(const NowPlayingMetadata&)>`.
+   */
+  using Func_void_NowPlayingMetadata = std::function<void(const NowPlayingMetadata& /* metadata */)>;
+  /**
+   * Wrapper class for a `std::function<void(const NowPlayingMetadata& / * metadata * /)>`, this can be used from Swift.
+   */
+  class Func_void_NowPlayingMetadata_Wrapper final {
+  public:
+    explicit Func_void_NowPlayingMetadata_Wrapper(std::function<void(const NowPlayingMetadata& /* metadata */)>&& func): _function(std::make_unique<std::function<void(const NowPlayingMetadata& /* metadata */)>>(std::move(func))) {}
+    inline void call(NowPlayingMetadata metadata) const noexcept {
+      _function->operator()(metadata);
+    }
+  private:
+    std::unique_ptr<std::function<void(const NowPlayingMetadata& /* metadata */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_NowPlayingMetadata create_Func_void_NowPlayingMetadata(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_NowPlayingMetadata_Wrapper wrap_Func_void_NowPlayingMetadata(Func_void_NowPlayingMetadata value) noexcept {
+    return Func_void_NowPlayingMetadata_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<std::function<void()>>
+  /**
+   * Specialized version of `std::optional<std::function<void()>>`.
+   */
+  using std__optional_std__function_void____ = std::optional<std::function<void()>>;
+  inline std::optional<std::function<void()>> create_std__optional_std__function_void____(const std::function<void()>& value) noexcept {
+    return std::optional<std::function<void()>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void____(const std::optional<std::function<void()>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void()> get_std__optional_std__function_void____(const std::optional<std::function<void()>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const RemoteJumpBackwardEvent& /* event */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const RemoteJumpBackwardEvent& / * event * /)>>`.
+   */
+  using std__optional_std__function_void_const_RemoteJumpBackwardEvent_____event______ = std::optional<std::function<void(const RemoteJumpBackwardEvent& /* event */)>>;
+  inline std::optional<std::function<void(const RemoteJumpBackwardEvent& /* event */)>> create_std__optional_std__function_void_const_RemoteJumpBackwardEvent_____event______(const std::function<void(const RemoteJumpBackwardEvent& /* event */)>& value) noexcept {
+    return std::optional<std::function<void(const RemoteJumpBackwardEvent& /* event */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_RemoteJumpBackwardEvent_____event______(const std::optional<std::function<void(const RemoteJumpBackwardEvent& /* event */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const RemoteJumpBackwardEvent& /* event */)> get_std__optional_std__function_void_const_RemoteJumpBackwardEvent_____event______(const std::optional<std::function<void(const RemoteJumpBackwardEvent& /* event */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const RemoteJumpForwardEvent& /* event */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const RemoteJumpForwardEvent& / * event * /)>>`.
+   */
+  using std__optional_std__function_void_const_RemoteJumpForwardEvent_____event______ = std::optional<std::function<void(const RemoteJumpForwardEvent& /* event */)>>;
+  inline std::optional<std::function<void(const RemoteJumpForwardEvent& /* event */)>> create_std__optional_std__function_void_const_RemoteJumpForwardEvent_____event______(const std::function<void(const RemoteJumpForwardEvent& /* event */)>& value) noexcept {
+    return std::optional<std::function<void(const RemoteJumpForwardEvent& /* event */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_RemoteJumpForwardEvent_____event______(const std::optional<std::function<void(const RemoteJumpForwardEvent& /* event */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const RemoteJumpForwardEvent& /* event */)> get_std__optional_std__function_void_const_RemoteJumpForwardEvent_____event______(const std::optional<std::function<void(const RemoteJumpForwardEvent& /* event */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const RemotePlayIdEvent& /* event */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const RemotePlayIdEvent& / * event * /)>>`.
+   */
+  using std__optional_std__function_void_const_RemotePlayIdEvent_____event______ = std::optional<std::function<void(const RemotePlayIdEvent& /* event */)>>;
+  inline std::optional<std::function<void(const RemotePlayIdEvent& /* event */)>> create_std__optional_std__function_void_const_RemotePlayIdEvent_____event______(const std::function<void(const RemotePlayIdEvent& /* event */)>& value) noexcept {
+    return std::optional<std::function<void(const RemotePlayIdEvent& /* event */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_RemotePlayIdEvent_____event______(const std::optional<std::function<void(const RemotePlayIdEvent& /* event */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const RemotePlayIdEvent& /* event */)> get_std__optional_std__function_void_const_RemotePlayIdEvent_____event______(const std::optional<std::function<void(const RemotePlayIdEvent& /* event */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const RemotePlaySearchEvent& /* event */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const RemotePlaySearchEvent& / * event * /)>>`.
+   */
+  using std__optional_std__function_void_const_RemotePlaySearchEvent_____event______ = std::optional<std::function<void(const RemotePlaySearchEvent& /* event */)>>;
+  inline std::optional<std::function<void(const RemotePlaySearchEvent& /* event */)>> create_std__optional_std__function_void_const_RemotePlaySearchEvent_____event______(const std::function<void(const RemotePlaySearchEvent& /* event */)>& value) noexcept {
+    return std::optional<std::function<void(const RemotePlaySearchEvent& /* event */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_RemotePlaySearchEvent_____event______(const std::optional<std::function<void(const RemotePlaySearchEvent& /* event */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const RemotePlaySearchEvent& /* event */)> get_std__optional_std__function_void_const_RemotePlaySearchEvent_____event______(const std::optional<std::function<void(const RemotePlaySearchEvent& /* event */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<std::function<void(const RemoteSeekEvent& /* event */)>>
+  /**
+   * Specialized version of `std::optional<std::function<void(const RemoteSeekEvent& / * event * /)>>`.
+   */
+  using std__optional_std__function_void_const_RemoteSeekEvent_____event______ = std::optional<std::function<void(const RemoteSeekEvent& /* event */)>>;
+  inline std::optional<std::function<void(const RemoteSeekEvent& /* event */)>> create_std__optional_std__function_void_const_RemoteSeekEvent_____event______(const std::function<void(const RemoteSeekEvent& /* event */)>& value) noexcept {
+    return std::optional<std::function<void(const RemoteSeekEvent& /* event */)>>(value);
+  }
+  inline bool has_value_std__optional_std__function_void_const_RemoteSeekEvent_____event______(const std::optional<std::function<void(const RemoteSeekEvent& /* event */)>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::function<void(const RemoteSeekEvent& /* event */)> get_std__optional_std__function_void_const_RemoteSeekEvent_____event______(const std::optional<std::function<void(const RemoteSeekEvent& /* event */)>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // 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;
+  }
+  
+  // pragma MARK: std::optional<NowPlayingMetadata>
+  /**
+   * Specialized version of `std::optional<NowPlayingMetadata>`.
+   */
+  using std__optional_NowPlayingMetadata_ = std::optional<NowPlayingMetadata>;
+  inline std::optional<NowPlayingMetadata> create_std__optional_NowPlayingMetadata_(const NowPlayingMetadata& value) noexcept {
+    return std::optional<NowPlayingMetadata>(value);
+  }
+  inline bool has_value_std__optional_NowPlayingMetadata_(const std::optional<NowPlayingMetadata>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline NowPlayingMetadata get_std__optional_NowPlayingMetadata_(const std::optional<NowPlayingMetadata>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(double /* volume */)>
+  /**
+   * Specialized version of `std::function<void(double)>`.
+   */
+  using Func_void_double = std::function<void(double /* volume */)>;
+  /**
+   * Wrapper class for a `std::function<void(double / * volume * /)>`, this can be used from Swift.
+   */
+  class Func_void_double_Wrapper final {
+  public:
+    explicit Func_void_double_Wrapper(std::function<void(double /* volume */)>&& func): _function(std::make_unique<std::function<void(double /* volume */)>>(std::move(func))) {}
+    inline void call(double volume) const noexcept {
+      _function->operator()(volume);
+    }
+  private:
+    std::unique_ptr<std::function<void(double /* volume */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_double create_Func_void_double(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_double_Wrapper wrap_Func_void_double(Func_void_double value) noexcept {
+    return Func_void_double_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<IosOutput>
+  /**
+   * Specialized version of `std::optional<IosOutput>`.
+   */
+  using std__optional_IosOutput_ = std::optional<IosOutput>;
+  inline std::optional<IosOutput> create_std__optional_IosOutput_(const IosOutput& value) noexcept {
+    return std::optional<IosOutput>(value);
+  }
+  inline bool has_value_std__optional_IosOutput_(const std::optional<IosOutput>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline IosOutput get_std__optional_IosOutput_(const std::optional<IosOutput>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const IosOutput& /* output */)>
+  /**
+   * Specialized version of `std::function<void(const IosOutput&)>`.
+   */
+  using Func_void_IosOutput = std::function<void(const IosOutput& /* output */)>;
+  /**
+   * Wrapper class for a `std::function<void(const IosOutput& / * output * /)>`, this can be used from Swift.
+   */
+  class Func_void_IosOutput_Wrapper final {
+  public:
+    explicit Func_void_IosOutput_Wrapper(std::function<void(const IosOutput& /* output */)>&& func): _function(std::make_unique<std::function<void(const IosOutput& /* output */)>>(std::move(func))) {}
+    inline void call(IosOutput output) const noexcept {
+      _function->operator()(output);
+    }
+  private:
+    std::unique_ptr<std::function<void(const IosOutput& /* output */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_IosOutput create_Func_void_IosOutput(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_IosOutput_Wrapper wrap_Func_void_IosOutput(Func_void_IosOutput value) noexcept {
+    return Func_void_IosOutput_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<EqualizerSettings>
+  /**
+   * Specialized version of `std::optional<EqualizerSettings>`.
+   */
+  using std__optional_EqualizerSettings_ = std::optional<EqualizerSettings>;
+  inline std::optional<EqualizerSettings> create_std__optional_EqualizerSettings_(const EqualizerSettings& value) noexcept {
+    return std::optional<EqualizerSettings>(value);
+  }
+  inline bool has_value_std__optional_EqualizerSettings_(const std::optional<EqualizerSettings>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline EqualizerSettings get_std__optional_EqualizerSettings_(const std::optional<EqualizerSettings>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const EqualizerSettings& /* settings */)>
+  /**
+   * Specialized version of `std::function<void(const EqualizerSettings&)>`.
+   */
+  using Func_void_EqualizerSettings = std::function<void(const EqualizerSettings& /* settings */)>;
+  /**
+   * Wrapper class for a `std::function<void(const EqualizerSettings& / * settings * /)>`, this can be used from Swift.
+   */
+  class Func_void_EqualizerSettings_Wrapper final {
+  public:
+    explicit Func_void_EqualizerSettings_Wrapper(std::function<void(const EqualizerSettings& /* settings */)>&& func): _function(std::make_unique<std::function<void(const EqualizerSettings& /* settings */)>>(std::move(func))) {}
+    inline void call(EqualizerSettings settings) const noexcept {
+      _function->operator()(settings);
+    }
+  private:
+    std::unique_ptr<std::function<void(const EqualizerSettings& /* settings */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_EqualizerSettings create_Func_void_EqualizerSettings(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_EqualizerSettings_Wrapper wrap_Func_void_EqualizerSettings(Func_void_EqualizerSettings value) noexcept {
+    return Func_void_EqualizerSettings_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const BatteryWarningPendingChangedEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const BatteryWarningPendingChangedEvent&)>`.
+   */
+  using Func_void_BatteryWarningPendingChangedEvent = std::function<void(const BatteryWarningPendingChangedEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const BatteryWarningPendingChangedEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_BatteryWarningPendingChangedEvent_Wrapper final {
+  public:
+    explicit Func_void_BatteryWarningPendingChangedEvent_Wrapper(std::function<void(const BatteryWarningPendingChangedEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const BatteryWarningPendingChangedEvent& /* event */)>>(std::move(func))) {}
+    inline void call(BatteryWarningPendingChangedEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const BatteryWarningPendingChangedEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_BatteryWarningPendingChangedEvent create_Func_void_BatteryWarningPendingChangedEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_BatteryWarningPendingChangedEvent_Wrapper wrap_Func_void_BatteryWarningPendingChangedEvent(Func_void_BatteryWarningPendingChangedEvent value) noexcept {
+    return Func_void_BatteryWarningPendingChangedEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const BatteryOptimizationStatusChangedEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const BatteryOptimizationStatusChangedEvent&)>`.
+   */
+  using Func_void_BatteryOptimizationStatusChangedEvent = std::function<void(const BatteryOptimizationStatusChangedEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const BatteryOptimizationStatusChangedEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_BatteryOptimizationStatusChangedEvent_Wrapper final {
+  public:
+    explicit Func_void_BatteryOptimizationStatusChangedEvent_Wrapper(std::function<void(const BatteryOptimizationStatusChangedEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const BatteryOptimizationStatusChangedEvent& /* event */)>>(std::move(func))) {}
+    inline void call(BatteryOptimizationStatusChangedEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const BatteryOptimizationStatusChangedEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_BatteryOptimizationStatusChangedEvent create_Func_void_BatteryOptimizationStatusChangedEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_BatteryOptimizationStatusChangedEvent_Wrapper wrap_Func_void_BatteryOptimizationStatusChangedEvent(Func_void_BatteryOptimizationStatusChangedEvent value) noexcept {
+    return Func_void_BatteryOptimizationStatusChangedEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridAudioBrowserSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridAudioBrowserSpec>`.
+   */
+  using std__shared_ptr_HybridAudioBrowserSpec_ = std::shared_ptr<HybridAudioBrowserSpec>;
+  std::shared_ptr<HybridAudioBrowserSpec> create_std__shared_ptr_HybridAudioBrowserSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridAudioBrowserSpec_(std__shared_ptr_HybridAudioBrowserSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridAudioBrowserSpec>
+  using std__weak_ptr_HybridAudioBrowserSpec_ = std::weak_ptr<HybridAudioBrowserSpec>;
+  inline std__weak_ptr_HybridAudioBrowserSpec_ weakify_std__shared_ptr_HybridAudioBrowserSpec_(const std::shared_ptr<HybridAudioBrowserSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() noexcept {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) noexcept {
+    return Result<void>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<Track>>>>
+  using Result_std__shared_ptr_Promise_std__vector_Track____ = Result<std::shared_ptr<Promise<std::vector<Track>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_Track____ create_Result_std__shared_ptr_Promise_std__vector_Track____(const std::shared_ptr<Promise<std::vector<Track>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<Track>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_Track____ create_Result_std__shared_ptr_Promise_std__vector_Track____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<Track>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<ResolvedTrack>>
+  using Result_std__optional_ResolvedTrack__ = Result<std::optional<ResolvedTrack>>;
+  inline Result_std__optional_ResolvedTrack__ create_Result_std__optional_ResolvedTrack__(const std::optional<ResolvedTrack>& value) noexcept {
+    return Result<std::optional<ResolvedTrack>>::withValue(value);
+  }
+  inline Result_std__optional_ResolvedTrack__ create_Result_std__optional_ResolvedTrack__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<ResolvedTrack>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<NavigationError>>
+  using Result_std__optional_NavigationError__ = Result<std::optional<NavigationError>>;
+  inline Result_std__optional_NavigationError__ create_Result_std__optional_NavigationError__(const std::optional<NavigationError>& value) noexcept {
+    return Result<std::optional<NavigationError>>::withValue(value);
+  }
+  inline Result_std__optional_NavigationError__ create_Result_std__optional_NavigationError__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<NavigationError>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<FormattedNavigationError>>
+  using Result_std__optional_FormattedNavigationError__ = Result<std::optional<FormattedNavigationError>>;
+  inline Result_std__optional_FormattedNavigationError__ create_Result_std__optional_FormattedNavigationError__(const std::optional<FormattedNavigationError>& value) noexcept {
+    return Result<std::optional<FormattedNavigationError>>::withValue(value);
+  }
+  inline Result_std__optional_FormattedNavigationError__ create_Result_std__optional_FormattedNavigationError__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<FormattedNavigationError>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<void>>>
+  using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<void>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<UpdateOptions>
+  using Result_UpdateOptions_ = Result<UpdateOptions>;
+  inline Result_UpdateOptions_ create_Result_UpdateOptions_(const UpdateOptions& value) noexcept {
+    return Result<UpdateOptions>::withValue(value);
+  }
+  inline Result_UpdateOptions_ create_Result_UpdateOptions_(const std::exception_ptr& error) noexcept {
+    return Result<UpdateOptions>::withError(error);
+  }
+  
+  // pragma MARK: Result<bool>
+  using Result_bool_ = Result<bool>;
+  inline Result_bool_ create_Result_bool_(bool value) noexcept {
+    return Result<bool>::withValue(std::move(value));
+  }
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
+    return Result<bool>::withError(error);
+  }
+  
+  // pragma MARK: Result<double>
+  using Result_double_ = Result<double>;
+  inline Result_double_ create_Result_double_(double value) noexcept {
+    return Result<double>::withValue(std::move(value));
+  }
+  inline Result_double_ create_Result_double_(const std::exception_ptr& error) noexcept {
+    return Result<double>::withError(error);
+  }
+  
+  // pragma MARK: Result<Progress>
+  using Result_Progress_ = Result<Progress>;
+  inline Result_Progress_ create_Result_Progress_(const Progress& value) noexcept {
+    return Result<Progress>::withValue(value);
+  }
+  inline Result_Progress_ create_Result_Progress_(const std::exception_ptr& error) noexcept {
+    return Result<Progress>::withError(error);
+  }
+  
+  // pragma MARK: Result<Playback>
+  using Result_Playback_ = Result<Playback>;
+  inline Result_Playback_ create_Result_Playback_(const Playback& value) noexcept {
+    return Result<Playback>::withValue(value);
+  }
+  inline Result_Playback_ create_Result_Playback_(const std::exception_ptr& error) noexcept {
+    return Result<Playback>::withError(error);
+  }
+  
+  // pragma MARK: Result<PlayingState>
+  using Result_PlayingState_ = Result<PlayingState>;
+  inline Result_PlayingState_ create_Result_PlayingState_(const PlayingState& value) noexcept {
+    return Result<PlayingState>::withValue(value);
+  }
+  inline Result_PlayingState_ create_Result_PlayingState_(const std::exception_ptr& error) noexcept {
+    return Result<PlayingState>::withError(error);
+  }
+  
+  // pragma MARK: Result<RepeatMode>
+  using Result_RepeatMode_ = Result<RepeatMode>;
+  inline Result_RepeatMode_ create_Result_RepeatMode_(RepeatMode value) noexcept {
+    return Result<RepeatMode>::withValue(std::move(value));
+  }
+  inline Result_RepeatMode_ create_Result_RepeatMode_(const std::exception_ptr& error) noexcept {
+    return Result<RepeatMode>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<PlaybackError>>
+  using Result_std__optional_PlaybackError__ = Result<std::optional<PlaybackError>>;
+  inline Result_std__optional_PlaybackError__ create_Result_std__optional_PlaybackError__(const std::optional<PlaybackError>& value) noexcept {
+    return Result<std::optional<PlaybackError>>::withValue(value);
+  }
+  inline Result_std__optional_PlaybackError__ create_Result_std__optional_PlaybackError__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<PlaybackError>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>
+  using Result_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__ = Result<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>;
+  inline Result_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__ create_Result_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__(const std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>& value) noexcept {
+    return Result<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>::withValue(value);
+  }
+  inline Result_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__ create_Result_std__variant_nitro__NullType__SleepTimerTime__SleepTimerEndOfTrack__(const std::exception_ptr& error) noexcept {
+    return Result<std::variant<nitro::NullType, SleepTimerTime, SleepTimerEndOfTrack>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::vector<Track>>
+  using Result_std__vector_Track__ = Result<std::vector<Track>>;
+  inline Result_std__vector_Track__ create_Result_std__vector_Track__(const std::vector<Track>& value) noexcept {
+    return Result<std::vector<Track>>::withValue(value);
+  }
+  inline Result_std__vector_Track__ create_Result_std__vector_Track__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<Track>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<Track>>
+  using Result_std__optional_Track__ = Result<std::optional<Track>>;
+  inline Result_std__optional_Track__ create_Result_std__optional_Track__(const std::optional<Track>& value) noexcept {
+    return Result<std::optional<Track>>::withValue(value);
+  }
+  inline Result_std__optional_Track__ create_Result_std__optional_Track__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<Track>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<double>>
+  using Result_std__optional_double__ = Result<std::optional<double>>;
+  inline Result_std__optional_double__ create_Result_std__optional_double__(std::optional<double> value) noexcept {
+    return Result<std::optional<double>>::withValue(std::move(value));
+  }
+  inline Result_std__optional_double__ create_Result_std__optional_double__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<double>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<NowPlayingMetadata>>
+  using Result_std__optional_NowPlayingMetadata__ = Result<std::optional<NowPlayingMetadata>>;
+  inline Result_std__optional_NowPlayingMetadata__ create_Result_std__optional_NowPlayingMetadata__(const std::optional<NowPlayingMetadata>& value) noexcept {
+    return Result<std::optional<NowPlayingMetadata>>::withValue(value);
+  }
+  inline Result_std__optional_NowPlayingMetadata__ create_Result_std__optional_NowPlayingMetadata__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<NowPlayingMetadata>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<IosOutput>>
+  using Result_std__optional_IosOutput__ = Result<std::optional<IosOutput>>;
+  inline Result_std__optional_IosOutput__ create_Result_std__optional_IosOutput__(const std::optional<IosOutput>& value) noexcept {
+    return Result<std::optional<IosOutput>>::withValue(value);
+  }
+  inline Result_std__optional_IosOutput__ create_Result_std__optional_IosOutput__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<IosOutput>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<EqualizerSettings>>
+  using Result_std__optional_EqualizerSettings__ = Result<std::optional<EqualizerSettings>>;
+  inline Result_std__optional_EqualizerSettings__ create_Result_std__optional_EqualizerSettings__(const std::optional<EqualizerSettings>& value) noexcept {
+    return Result<std::optional<EqualizerSettings>>::withValue(value);
+  }
+  inline Result_std__optional_EqualizerSettings__ create_Result_std__optional_EqualizerSettings__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<EqualizerSettings>>::withError(error);
+  }
+  
+  // pragma MARK: Result<BatteryOptimizationStatus>
+  using Result_BatteryOptimizationStatus_ = Result<BatteryOptimizationStatus>;
+  inline Result_BatteryOptimizationStatus_ create_Result_BatteryOptimizationStatus_(BatteryOptimizationStatus value) noexcept {
+    return Result<BatteryOptimizationStatus>::withValue(std::move(value));
+  }
+  inline Result_BatteryOptimizationStatus_ create_Result_BatteryOptimizationStatus_(const std::exception_ptr& error) noexcept {
+    return Result<BatteryOptimizationStatus>::withError(error);
+  }
+
+} // namespace margelo::nitro::audiobrowser::bridge::swift