react-native-queue-player 1.0.0

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

@@ -0,0 +1,1831 @@
+///
+/// QueuePlayer-Swift-Cxx-Bridge.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declarations of C++ defined types
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
+// Forward declaration of `AudioCategoryOptions` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct AudioCategoryOptions; }
+// Forward declaration of `AudioCodec` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class AudioCodec; }
+// Forward declaration of `AudioContainer` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class AudioContainer; }
+// Forward declaration of `AudioContentType` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class AudioContentType; }
+// Forward declaration of `AudioRouteKind` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class AudioRouteKind; }
+// Forward declaration of `AudioRoute` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct AudioRoute; }
+// Forward declaration of `BrowseItem` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct BrowseItem; }
+// Forward declaration of `BrowseSection` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct BrowseSection; }
+// Forward declaration of `BufferState` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class BufferState; }
+// Forward declaration of `CacheStatus` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CacheStatus; }
+// Forward declaration of `CastDeviceKind` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class CastDeviceKind; }
+// Forward declaration of `CastDiscoveryState` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CastDiscoveryState; }
+// Forward declaration of `CastLocalNetworkPermissionEvent` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CastLocalNetworkPermissionEvent; }
+// Forward declaration of `CastLocalNetworkPermission` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class CastLocalNetworkPermission; }
+// Forward declaration of `CastProtocol` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class CastProtocol; }
+// Forward declaration of `CastReceiverCapabilities` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CastReceiverCapabilities; }
+// Forward declaration of `CastReceiver` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CastReceiver; }
+// Forward declaration of `CastRoute` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CastRoute; }
+// Forward declaration of `CastSessionDiedEvent` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct CastSessionDiedEvent; }
+// Forward declaration of `CastSessionEndReason` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class CastSessionEndReason; }
+// Forward declaration of `CastStreamingModel` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class CastStreamingModel; }
+// Forward declaration of `EqualizerBand` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct EqualizerBand; }
+// Forward declaration of `EqualizerPreset` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct EqualizerPreset; }
+// Forward declaration of `EvictionPolicy` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class EvictionPolicy; }
+// Forward declaration of `HybridCastManagerSpec` to properly resolve imports.
+namespace margelo::nitro::queueplayer { class HybridCastManagerSpec; }
+// Forward declaration of `HybridEqualizerSpec` to properly resolve imports.
+namespace margelo::nitro::queueplayer { class HybridEqualizerSpec; }
+// Forward declaration of `HybridTrackPlayerSpec` to properly resolve imports.
+namespace margelo::nitro::queueplayer { class HybridTrackPlayerSpec; }
+// Forward declaration of `HybridVisualizerSpec` to properly resolve imports.
+namespace margelo::nitro::queueplayer { class HybridVisualizerSpec; }
+// Forward declaration of `MediaSearchOrigin` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class MediaSearchOrigin; }
+// Forward declaration of `MediaSearchQueueLocation` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class MediaSearchQueueLocation; }
+// Forward declaration of `MediaSearchReference` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class MediaSearchReference; }
+// Forward declaration of `MediaSearchReleaseDateRange` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct MediaSearchReleaseDateRange; }
+// Forward declaration of `MediaSearchRepeatMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class MediaSearchRepeatMode; }
+// Forward declaration of `MediaSearchRequest` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct MediaSearchRequest; }
+// Forward declaration of `MediaSearchType` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class MediaSearchType; }
+// Forward declaration of `NowPlayingFormatAndroidExtras` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct NowPlayingFormatAndroidExtras; }
+// Forward declaration of `NowPlayingFormatIosExtras` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct NowPlayingFormatIosExtras; }
+// Forward declaration of `NowPlayingFormat` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct NowPlayingFormat; }
+// Forward declaration of `PitchCorrectionMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class PitchCorrectionMode; }
+// Forward declaration of `PlaybackErrorCode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class PlaybackErrorCode; }
+// Forward declaration of `PlaybackError` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct PlaybackError; }
+// Forward declaration of `PlaybackMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct PlaybackMode; }
+// Forward declaration of `PlayerProgress` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct PlayerProgress; }
+// Forward declaration of `PlayerState` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class PlayerState; }
+// Forward declaration of `RemoteControlOptions` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct RemoteControlOptions; }
+// Forward declaration of `ReplayGainMode` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class ReplayGainMode; }
+// Forward declaration of `SectionIcon` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class SectionIcon; }
+// Forward declaration of `ServiceReadyReason` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class ServiceReadyReason; }
+// Forward declaration of `ShuffleResult` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct ShuffleResult; }
+// Forward declaration of `SkipCapability` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct SkipCapability; }
+// Forward declaration of `SleepTimerState` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct SleepTimerState; }
+// Forward declaration of `StateChangeReason` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class StateChangeReason; }
+// Forward declaration of `TrackChangeReason` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class TrackChangeReason; }
+// Forward declaration of `TrackItem` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct TrackItem; }
+// Forward declaration of `TrackSource` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class TrackSource; }
+// Forward declaration of `VisualizerErrorReason` to properly resolve imports.
+namespace margelo::nitro::queueplayer { enum class VisualizerErrorReason; }
+// Forward declaration of `VisualizerFrame` to properly resolve imports.
+namespace margelo::nitro::queueplayer { struct VisualizerFrame; }
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridCastManagerSpec_cxx` to properly resolve imports.
+namespace QueuePlayer { class HybridCastManagerSpec_cxx; }
+// Forward declaration of `HybridEqualizerSpec_cxx` to properly resolve imports.
+namespace QueuePlayer { class HybridEqualizerSpec_cxx; }
+// Forward declaration of `HybridTrackPlayerSpec_cxx` to properly resolve imports.
+namespace QueuePlayer { class HybridTrackPlayerSpec_cxx; }
+// Forward declaration of `HybridVisualizerSpec_cxx` to properly resolve imports.
+namespace QueuePlayer { class HybridVisualizerSpec_cxx; }
+
+// Include C++ defined types
+#include "AudioCategoryOptions.hpp"
+#include "AudioCodec.hpp"
+#include "AudioContainer.hpp"
+#include "AudioContentType.hpp"
+#include "AudioRoute.hpp"
+#include "AudioRouteKind.hpp"
+#include "BrowseItem.hpp"
+#include "BrowseSection.hpp"
+#include "BufferState.hpp"
+#include "CacheStatus.hpp"
+#include "CastDeviceKind.hpp"
+#include "CastDiscoveryState.hpp"
+#include "CastLocalNetworkPermission.hpp"
+#include "CastLocalNetworkPermissionEvent.hpp"
+#include "CastProtocol.hpp"
+#include "CastReceiver.hpp"
+#include "CastReceiverCapabilities.hpp"
+#include "CastRoute.hpp"
+#include "CastSessionDiedEvent.hpp"
+#include "CastSessionEndReason.hpp"
+#include "CastStreamingModel.hpp"
+#include "EqualizerBand.hpp"
+#include "EqualizerPreset.hpp"
+#include "EvictionPolicy.hpp"
+#include "HybridCastManagerSpec.hpp"
+#include "HybridEqualizerSpec.hpp"
+#include "HybridTrackPlayerSpec.hpp"
+#include "HybridVisualizerSpec.hpp"
+#include "MediaSearchOrigin.hpp"
+#include "MediaSearchQueueLocation.hpp"
+#include "MediaSearchReference.hpp"
+#include "MediaSearchReleaseDateRange.hpp"
+#include "MediaSearchRepeatMode.hpp"
+#include "MediaSearchRequest.hpp"
+#include "MediaSearchType.hpp"
+#include "NowPlayingFormat.hpp"
+#include "NowPlayingFormatAndroidExtras.hpp"
+#include "NowPlayingFormatIosExtras.hpp"
+#include "PitchCorrectionMode.hpp"
+#include "PlaybackError.hpp"
+#include "PlaybackErrorCode.hpp"
+#include "PlaybackMode.hpp"
+#include "PlayerProgress.hpp"
+#include "PlayerState.hpp"
+#include "RemoteControlOptions.hpp"
+#include "ReplayGainMode.hpp"
+#include "SectionIcon.hpp"
+#include "ServiceReadyReason.hpp"
+#include "ShuffleResult.hpp"
+#include "SkipCapability.hpp"
+#include "SleepTimerState.hpp"
+#include "StateChangeReason.hpp"
+#include "TrackChangeReason.hpp"
+#include "TrackItem.hpp"
+#include "TrackSource.hpp"
+#include "VisualizerErrorReason.hpp"
+#include "VisualizerFrame.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.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::queueplayer::bridge::swift {
+
+  // pragma MARK: std::vector<CastProtocol>
+  /**
+   * Specialized version of `std::vector<CastProtocol>`.
+   */
+  using std__vector_CastProtocol_ = std::vector<CastProtocol>;
+  inline std::vector<CastProtocol> create_std__vector_CastProtocol_(size_t size) noexcept {
+    std::vector<CastProtocol> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<void>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<void>>`.
+   */
+  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
+  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() noexcept {
+    return Promise<void>::create();
+  }
+  inline PromiseHolder<void> wrap_std__shared_ptr_Promise_void__(std::shared_ptr<Promise<void>> promise) noexcept {
+    return PromiseHolder<void>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void()>
+  /**
+   * Specialized version of `std::function<void()>`.
+   */
+  using Func_void = std::function<void()>;
+  /**
+   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
+   */
+  class Func_void_Wrapper final {
+  public:
+    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::make_unique<std::function<void()>>(std::move(func))) {}
+    inline void call() const noexcept {
+      _function->operator()();
+    }
+  private:
+    std::unique_ptr<std::function<void()>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void create_Func_void(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_Wrapper wrap_Func_void(Func_void value) noexcept {
+    return Func_void_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<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<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
+  }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::vector<CastReceiver>
+  /**
+   * Specialized version of `std::vector<CastReceiver>`.
+   */
+  using std__vector_CastReceiver_ = std::vector<CastReceiver>;
+  inline std::vector<CastReceiver> create_std__vector_CastReceiver_(size_t size) noexcept {
+    std::vector<CastReceiver> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<CastLocalNetworkPermission>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<CastLocalNetworkPermission>>`.
+   */
+  using std__shared_ptr_Promise_CastLocalNetworkPermission__ = std::shared_ptr<Promise<CastLocalNetworkPermission>>;
+  inline std::shared_ptr<Promise<CastLocalNetworkPermission>> create_std__shared_ptr_Promise_CastLocalNetworkPermission__() noexcept {
+    return Promise<CastLocalNetworkPermission>::create();
+  }
+  inline PromiseHolder<CastLocalNetworkPermission> wrap_std__shared_ptr_Promise_CastLocalNetworkPermission__(std::shared_ptr<Promise<CastLocalNetworkPermission>> promise) noexcept {
+    return PromiseHolder<CastLocalNetworkPermission>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(CastLocalNetworkPermission /* result */)>
+  /**
+   * Specialized version of `std::function<void(CastLocalNetworkPermission)>`.
+   */
+  using Func_void_CastLocalNetworkPermission = std::function<void(CastLocalNetworkPermission /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(CastLocalNetworkPermission / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_CastLocalNetworkPermission_Wrapper final {
+  public:
+    explicit Func_void_CastLocalNetworkPermission_Wrapper(std::function<void(CastLocalNetworkPermission /* result */)>&& func): _function(std::make_unique<std::function<void(CastLocalNetworkPermission /* result */)>>(std::move(func))) {}
+    inline void call(int result) const noexcept {
+      _function->operator()(static_cast<CastLocalNetworkPermission>(result));
+    }
+  private:
+    std::unique_ptr<std::function<void(CastLocalNetworkPermission /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_CastLocalNetworkPermission create_Func_void_CastLocalNetworkPermission(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_CastLocalNetworkPermission_Wrapper wrap_Func_void_CastLocalNetworkPermission(Func_void_CastLocalNetworkPermission value) noexcept {
+    return Func_void_CastLocalNetworkPermission_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const CastRoute& /* route */)>
+  /**
+   * Specialized version of `std::function<void(const CastRoute&)>`.
+   */
+  using Func_void_CastRoute = std::function<void(const CastRoute& /* route */)>;
+  /**
+   * Wrapper class for a `std::function<void(const CastRoute& / * route * /)>`, this can be used from Swift.
+   */
+  class Func_void_CastRoute_Wrapper final {
+  public:
+    explicit Func_void_CastRoute_Wrapper(std::function<void(const CastRoute& /* route */)>&& func): _function(std::make_unique<std::function<void(const CastRoute& /* route */)>>(std::move(func))) {}
+    inline void call(CastRoute route) const noexcept {
+      _function->operator()(route);
+    }
+  private:
+    std::unique_ptr<std::function<void(const CastRoute& /* route */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_CastRoute create_Func_void_CastRoute(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_CastRoute_Wrapper wrap_Func_void_CastRoute(Func_void_CastRoute value) noexcept {
+    return Func_void_CastRoute_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<CastReceiver>& /* receivers */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<CastReceiver>&)>`.
+   */
+  using Func_void_std__vector_CastReceiver_ = std::function<void(const std::vector<CastReceiver>& /* receivers */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<CastReceiver>& / * receivers * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_CastReceiver__Wrapper final {
+  public:
+    explicit Func_void_std__vector_CastReceiver__Wrapper(std::function<void(const std::vector<CastReceiver>& /* receivers */)>&& func): _function(std::make_unique<std::function<void(const std::vector<CastReceiver>& /* receivers */)>>(std::move(func))) {}
+    inline void call(std::vector<CastReceiver> receivers) const noexcept {
+      _function->operator()(receivers);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<CastReceiver>& /* receivers */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_CastReceiver_ create_Func_void_std__vector_CastReceiver_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_CastReceiver__Wrapper wrap_Func_void_std__vector_CastReceiver_(Func_void_std__vector_CastReceiver_ value) noexcept {
+    return Func_void_std__vector_CastReceiver__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const CastDiscoveryState& /* state */)>
+  /**
+   * Specialized version of `std::function<void(const CastDiscoveryState&)>`.
+   */
+  using Func_void_CastDiscoveryState = std::function<void(const CastDiscoveryState& /* state */)>;
+  /**
+   * Wrapper class for a `std::function<void(const CastDiscoveryState& / * state * /)>`, this can be used from Swift.
+   */
+  class Func_void_CastDiscoveryState_Wrapper final {
+  public:
+    explicit Func_void_CastDiscoveryState_Wrapper(std::function<void(const CastDiscoveryState& /* state */)>&& func): _function(std::make_unique<std::function<void(const CastDiscoveryState& /* state */)>>(std::move(func))) {}
+    inline void call(CastDiscoveryState state) const noexcept {
+      _function->operator()(state);
+    }
+  private:
+    std::unique_ptr<std::function<void(const CastDiscoveryState& /* state */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_CastDiscoveryState create_Func_void_CastDiscoveryState(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_CastDiscoveryState_Wrapper wrap_Func_void_CastDiscoveryState(Func_void_CastDiscoveryState value) noexcept {
+    return Func_void_CastDiscoveryState_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const CastSessionDiedEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const CastSessionDiedEvent&)>`.
+   */
+  using Func_void_CastSessionDiedEvent = std::function<void(const CastSessionDiedEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const CastSessionDiedEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_CastSessionDiedEvent_Wrapper final {
+  public:
+    explicit Func_void_CastSessionDiedEvent_Wrapper(std::function<void(const CastSessionDiedEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const CastSessionDiedEvent& /* event */)>>(std::move(func))) {}
+    inline void call(CastSessionDiedEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const CastSessionDiedEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_CastSessionDiedEvent create_Func_void_CastSessionDiedEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_CastSessionDiedEvent_Wrapper wrap_Func_void_CastSessionDiedEvent(Func_void_CastSessionDiedEvent value) noexcept {
+    return Func_void_CastSessionDiedEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const CastLocalNetworkPermissionEvent& /* event */)>
+  /**
+   * Specialized version of `std::function<void(const CastLocalNetworkPermissionEvent&)>`.
+   */
+  using Func_void_CastLocalNetworkPermissionEvent = std::function<void(const CastLocalNetworkPermissionEvent& /* event */)>;
+  /**
+   * Wrapper class for a `std::function<void(const CastLocalNetworkPermissionEvent& / * event * /)>`, this can be used from Swift.
+   */
+  class Func_void_CastLocalNetworkPermissionEvent_Wrapper final {
+  public:
+    explicit Func_void_CastLocalNetworkPermissionEvent_Wrapper(std::function<void(const CastLocalNetworkPermissionEvent& /* event */)>&& func): _function(std::make_unique<std::function<void(const CastLocalNetworkPermissionEvent& /* event */)>>(std::move(func))) {}
+    inline void call(CastLocalNetworkPermissionEvent event) const noexcept {
+      _function->operator()(event);
+    }
+  private:
+    std::unique_ptr<std::function<void(const CastLocalNetworkPermissionEvent& /* event */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_CastLocalNetworkPermissionEvent create_Func_void_CastLocalNetworkPermissionEvent(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_CastLocalNetworkPermissionEvent_Wrapper wrap_Func_void_CastLocalNetworkPermissionEvent(Func_void_CastLocalNetworkPermissionEvent value) noexcept {
+    return Func_void_CastLocalNetworkPermissionEvent_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const AudioRoute& /* route */)>
+  /**
+   * Specialized version of `std::function<void(const AudioRoute&)>`.
+   */
+  using Func_void_AudioRoute = std::function<void(const AudioRoute& /* route */)>;
+  /**
+   * Wrapper class for a `std::function<void(const AudioRoute& / * route * /)>`, this can be used from Swift.
+   */
+  class Func_void_AudioRoute_Wrapper final {
+  public:
+    explicit Func_void_AudioRoute_Wrapper(std::function<void(const AudioRoute& /* route */)>&& func): _function(std::make_unique<std::function<void(const AudioRoute& /* route */)>>(std::move(func))) {}
+    inline void call(AudioRoute route) const noexcept {
+      _function->operator()(route);
+    }
+  private:
+    std::unique_ptr<std::function<void(const AudioRoute& /* route */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_AudioRoute create_Func_void_AudioRoute(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_AudioRoute_Wrapper wrap_Func_void_AudioRoute(Func_void_AudioRoute value) noexcept {
+    return Func_void_AudioRoute_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridCastManagerSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridCastManagerSpec>`.
+   */
+  using std__shared_ptr_HybridCastManagerSpec_ = std::shared_ptr<HybridCastManagerSpec>;
+  std::shared_ptr<HybridCastManagerSpec> create_std__shared_ptr_HybridCastManagerSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridCastManagerSpec_(std__shared_ptr_HybridCastManagerSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridCastManagerSpec>
+  using std__weak_ptr_HybridCastManagerSpec_ = std::weak_ptr<HybridCastManagerSpec>;
+  inline std__weak_ptr_HybridCastManagerSpec_ weakify_std__shared_ptr_HybridCastManagerSpec_(const std::shared_ptr<HybridCastManagerSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::vector<CastProtocol>>
+  using Result_std__vector_CastProtocol__ = Result<std::vector<CastProtocol>>;
+  inline Result_std__vector_CastProtocol__ create_Result_std__vector_CastProtocol__(const std::vector<CastProtocol>& value) noexcept {
+    return Result<std::vector<CastProtocol>>::withValue(value);
+  }
+  inline Result_std__vector_CastProtocol__ create_Result_std__vector_CastProtocol__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<CastProtocol>>::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<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<std::vector<CastReceiver>>
+  using Result_std__vector_CastReceiver__ = Result<std::vector<CastReceiver>>;
+  inline Result_std__vector_CastReceiver__ create_Result_std__vector_CastReceiver__(const std::vector<CastReceiver>& value) noexcept {
+    return Result<std::vector<CastReceiver>>::withValue(value);
+  }
+  inline Result_std__vector_CastReceiver__ create_Result_std__vector_CastReceiver__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<CastReceiver>>::withError(error);
+  }
+  
+  // pragma MARK: Result<CastRoute>
+  using Result_CastRoute_ = Result<CastRoute>;
+  inline Result_CastRoute_ create_Result_CastRoute_(const CastRoute& value) noexcept {
+    return Result<CastRoute>::withValue(value);
+  }
+  inline Result_CastRoute_ create_Result_CastRoute_(const std::exception_ptr& error) noexcept {
+    return Result<CastRoute>::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<CastLocalNetworkPermission>
+  using Result_CastLocalNetworkPermission_ = Result<CastLocalNetworkPermission>;
+  inline Result_CastLocalNetworkPermission_ create_Result_CastLocalNetworkPermission_(CastLocalNetworkPermission value) noexcept {
+    return Result<CastLocalNetworkPermission>::withValue(std::move(value));
+  }
+  inline Result_CastLocalNetworkPermission_ create_Result_CastLocalNetworkPermission_(const std::exception_ptr& error) noexcept {
+    return Result<CastLocalNetworkPermission>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<CastLocalNetworkPermission>>>
+  using Result_std__shared_ptr_Promise_CastLocalNetworkPermission___ = Result<std::shared_ptr<Promise<CastLocalNetworkPermission>>>;
+  inline Result_std__shared_ptr_Promise_CastLocalNetworkPermission___ create_Result_std__shared_ptr_Promise_CastLocalNetworkPermission___(const std::shared_ptr<Promise<CastLocalNetworkPermission>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<CastLocalNetworkPermission>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_CastLocalNetworkPermission___ create_Result_std__shared_ptr_Promise_CastLocalNetworkPermission___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<CastLocalNetworkPermission>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::function<void()>>
+  using Result_std__function_void____ = Result<std::function<void()>>;
+  inline Result_std__function_void____ create_Result_std__function_void____(const std::function<void()>& value) noexcept {
+    return Result<std::function<void()>>::withValue(value);
+  }
+  inline Result_std__function_void____ create_Result_std__function_void____(const std::exception_ptr& error) noexcept {
+    return Result<std::function<void()>>::withError(error);
+  }
+  
+  // pragma MARK: Result<AudioRoute>
+  using Result_AudioRoute_ = Result<AudioRoute>;
+  inline Result_AudioRoute_ create_Result_AudioRoute_(const AudioRoute& value) noexcept {
+    return Result<AudioRoute>::withValue(value);
+  }
+  inline Result_AudioRoute_ create_Result_AudioRoute_(const std::exception_ptr& error) noexcept {
+    return Result<AudioRoute>::withError(error);
+  }
+  
+  // pragma MARK: std::vector<EqualizerBand>
+  /**
+   * Specialized version of `std::vector<EqualizerBand>`.
+   */
+  using std__vector_EqualizerBand_ = std::vector<EqualizerBand>;
+  inline std::vector<EqualizerBand> create_std__vector_EqualizerBand_(size_t size) noexcept {
+    std::vector<EqualizerBand> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // 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::vector<EqualizerPreset>
+  /**
+   * Specialized version of `std::vector<EqualizerPreset>`.
+   */
+  using std__vector_EqualizerPreset_ = std::vector<EqualizerPreset>;
+  inline std::vector<EqualizerPreset> create_std__vector_EqualizerPreset_(size_t size) noexcept {
+    std::vector<EqualizerPreset> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<EqualizerBand>& /* bands */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<EqualizerBand>&)>`.
+   */
+  using Func_void_std__vector_EqualizerBand_ = std::function<void(const std::vector<EqualizerBand>& /* bands */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<EqualizerBand>& / * bands * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_EqualizerBand__Wrapper final {
+  public:
+    explicit Func_void_std__vector_EqualizerBand__Wrapper(std::function<void(const std::vector<EqualizerBand>& /* bands */)>&& func): _function(std::make_unique<std::function<void(const std::vector<EqualizerBand>& /* bands */)>>(std::move(func))) {}
+    inline void call(std::vector<EqualizerBand> bands) const noexcept {
+      _function->operator()(bands);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<EqualizerBand>& /* bands */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_EqualizerBand_ create_Func_void_std__vector_EqualizerBand_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_EqualizerBand__Wrapper wrap_Func_void_std__vector_EqualizerBand_(Func_void_std__vector_EqualizerBand_ value) noexcept {
+    return Func_void_std__vector_EqualizerBand__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::shared_ptr<HybridEqualizerSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridEqualizerSpec>`.
+   */
+  using std__shared_ptr_HybridEqualizerSpec_ = std::shared_ptr<HybridEqualizerSpec>;
+  std::shared_ptr<HybridEqualizerSpec> create_std__shared_ptr_HybridEqualizerSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridEqualizerSpec_(std__shared_ptr_HybridEqualizerSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridEqualizerSpec>
+  using std__weak_ptr_HybridEqualizerSpec_ = std::weak_ptr<HybridEqualizerSpec>;
+  inline std__weak_ptr_HybridEqualizerSpec_ weakify_std__shared_ptr_HybridEqualizerSpec_(const std::shared_ptr<HybridEqualizerSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::vector<EqualizerBand>>
+  using Result_std__vector_EqualizerBand__ = Result<std::vector<EqualizerBand>>;
+  inline Result_std__vector_EqualizerBand__ create_Result_std__vector_EqualizerBand__(const std::vector<EqualizerBand>& value) noexcept {
+    return Result<std::vector<EqualizerBand>>::withValue(value);
+  }
+  inline Result_std__vector_EqualizerBand__ create_Result_std__vector_EqualizerBand__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<EqualizerBand>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::vector<EqualizerPreset>>
+  using Result_std__vector_EqualizerPreset__ = Result<std::vector<EqualizerPreset>>;
+  inline Result_std__vector_EqualizerPreset__ create_Result_std__vector_EqualizerPreset__(const std::vector<EqualizerPreset>& value) noexcept {
+    return Result<std::vector<EqualizerPreset>>::withValue(value);
+  }
+  inline Result_std__vector_EqualizerPreset__ create_Result_std__vector_EqualizerPreset__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<EqualizerPreset>>::withError(error);
+  }
+  
+  // 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<std::unordered_map<std::string, std::string>>
+  /**
+   * Specialized version of `std::optional<std::unordered_map<std::string, std::string>>`.
+   */
+  using std__optional_std__unordered_map_std__string__std__string__ = std::optional<std::unordered_map<std::string, std::string>>;
+  inline std::optional<std::unordered_map<std::string, std::string>> create_std__optional_std__unordered_map_std__string__std__string__(const std::unordered_map<std::string, std::string>& value) noexcept {
+    return std::optional<std::unordered_map<std::string, std::string>>(value);
+  }
+  inline bool has_value_std__optional_std__unordered_map_std__string__std__string__(const std::optional<std::unordered_map<std::string, std::string>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::unordered_map<std::string, std::string> get_std__optional_std__unordered_map_std__string__std__string__(const std::optional<std::unordered_map<std::string, std::string>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::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.value();
+  }
+  
+  // 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.value();
+  }
+  
+  // pragma MARK: std::optional<AudioContentType>
+  /**
+   * Specialized version of `std::optional<AudioContentType>`.
+   */
+  using std__optional_AudioContentType_ = std::optional<AudioContentType>;
+  inline std::optional<AudioContentType> create_std__optional_AudioContentType_(const AudioContentType& value) noexcept {
+    return std::optional<AudioContentType>(value);
+  }
+  inline bool has_value_std__optional_AudioContentType_(const std::optional<AudioContentType>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline AudioContentType get_std__optional_AudioContentType_(const std::optional<AudioContentType>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<AudioCategoryOptions>
+  /**
+   * Specialized version of `std::optional<AudioCategoryOptions>`.
+   */
+  using std__optional_AudioCategoryOptions_ = std::optional<AudioCategoryOptions>;
+  inline std::optional<AudioCategoryOptions> create_std__optional_AudioCategoryOptions_(const AudioCategoryOptions& value) noexcept {
+    return std::optional<AudioCategoryOptions>(value);
+  }
+  inline bool has_value_std__optional_AudioCategoryOptions_(const std::optional<AudioCategoryOptions>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline AudioCategoryOptions get_std__optional_AudioCategoryOptions_(const std::optional<AudioCategoryOptions>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<EvictionPolicy>
+  /**
+   * Specialized version of `std::optional<EvictionPolicy>`.
+   */
+  using std__optional_EvictionPolicy_ = std::optional<EvictionPolicy>;
+  inline std::optional<EvictionPolicy> create_std__optional_EvictionPolicy_(const EvictionPolicy& value) noexcept {
+    return std::optional<EvictionPolicy>(value);
+  }
+  inline bool has_value_std__optional_EvictionPolicy_(const std::optional<EvictionPolicy>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline EvictionPolicy get_std__optional_EvictionPolicy_(const std::optional<EvictionPolicy>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::vector<TrackItem>
+  /**
+   * Specialized version of `std::vector<TrackItem>`.
+   */
+  using std__vector_TrackItem_ = std::vector<TrackItem>;
+  inline std::vector<TrackItem> create_std__vector_TrackItem_(size_t size) noexcept {
+    std::vector<TrackItem> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<TrackItem>
+  /**
+   * Specialized version of `std::optional<TrackItem>`.
+   */
+  using std__optional_TrackItem_ = std::optional<TrackItem>;
+  inline std::optional<TrackItem> create_std__optional_TrackItem_(const TrackItem& value) noexcept {
+    return std::optional<TrackItem>(value);
+  }
+  inline bool has_value_std__optional_TrackItem_(const std::optional<TrackItem>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline TrackItem get_std__optional_TrackItem_(const std::optional<TrackItem>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<ShuffleResult>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<ShuffleResult>>`.
+   */
+  using std__shared_ptr_Promise_ShuffleResult__ = std::shared_ptr<Promise<ShuffleResult>>;
+  inline std::shared_ptr<Promise<ShuffleResult>> create_std__shared_ptr_Promise_ShuffleResult__() noexcept {
+    return Promise<ShuffleResult>::create();
+  }
+  inline PromiseHolder<ShuffleResult> wrap_std__shared_ptr_Promise_ShuffleResult__(std::shared_ptr<Promise<ShuffleResult>> promise) noexcept {
+    return PromiseHolder<ShuffleResult>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const ShuffleResult& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const ShuffleResult&)>`.
+   */
+  using Func_void_ShuffleResult = std::function<void(const ShuffleResult& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const ShuffleResult& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_ShuffleResult_Wrapper final {
+  public:
+    explicit Func_void_ShuffleResult_Wrapper(std::function<void(const ShuffleResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const ShuffleResult& /* result */)>>(std::move(func))) {}
+    inline void call(ShuffleResult result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const ShuffleResult& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_ShuffleResult create_Func_void_ShuffleResult(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_ShuffleResult_Wrapper wrap_Func_void_ShuffleResult(Func_void_ShuffleResult value) noexcept {
+    return Func_void_ShuffleResult_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<TrackSource>
+  /**
+   * Specialized version of `std::optional<TrackSource>`.
+   */
+  using std__optional_TrackSource_ = std::optional<TrackSource>;
+  inline std::optional<TrackSource> create_std__optional_TrackSource_(const TrackSource& value) noexcept {
+    return std::optional<TrackSource>(value);
+  }
+  inline bool has_value_std__optional_TrackSource_(const std::optional<TrackSource>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline TrackSource get_std__optional_TrackSource_(const std::optional<TrackSource>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::function<void(PlayerState /* state */, StateChangeReason /* reason */)>
+  /**
+   * Specialized version of `std::function<void(PlayerState, StateChangeReason)>`.
+   */
+  using Func_void_PlayerState_StateChangeReason = std::function<void(PlayerState /* state */, StateChangeReason /* reason */)>;
+  /**
+   * Wrapper class for a `std::function<void(PlayerState / * state * /, StateChangeReason / * reason * /)>`, this can be used from Swift.
+   */
+  class Func_void_PlayerState_StateChangeReason_Wrapper final {
+  public:
+    explicit Func_void_PlayerState_StateChangeReason_Wrapper(std::function<void(PlayerState /* state */, StateChangeReason /* reason */)>&& func): _function(std::make_unique<std::function<void(PlayerState /* state */, StateChangeReason /* reason */)>>(std::move(func))) {}
+    inline void call(int state, int reason) const noexcept {
+      _function->operator()(static_cast<PlayerState>(state), static_cast<StateChangeReason>(reason));
+    }
+  private:
+    std::unique_ptr<std::function<void(PlayerState /* state */, StateChangeReason /* reason */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_PlayerState_StateChangeReason create_Func_void_PlayerState_StateChangeReason(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_PlayerState_StateChangeReason_Wrapper wrap_Func_void_PlayerState_StateChangeReason(Func_void_PlayerState_StateChangeReason value) noexcept {
+    return Func_void_PlayerState_StateChangeReason_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<TrackItem>& /* track */, double /* index */, TrackChangeReason /* reason */, std::optional<double> /* transitionGapMs */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<TrackItem>&, double, TrackChangeReason, std::optional<double>)>`.
+   */
+  using Func_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double_ = std::function<void(const std::optional<TrackItem>& /* track */, double /* index */, TrackChangeReason /* reason */, std::optional<double> /* transitionGapMs */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<TrackItem>& / * track * /, double / * index * /, TrackChangeReason / * reason * /, std::optional<double> / * transitionGapMs * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double__Wrapper final {
+  public:
+    explicit Func_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double__Wrapper(std::function<void(const std::optional<TrackItem>& /* track */, double /* index */, TrackChangeReason /* reason */, std::optional<double> /* transitionGapMs */)>&& func): _function(std::make_unique<std::function<void(const std::optional<TrackItem>& /* track */, double /* index */, TrackChangeReason /* reason */, std::optional<double> /* transitionGapMs */)>>(std::move(func))) {}
+    inline void call(std::optional<TrackItem> track, double index, int reason, std::optional<double> transitionGapMs) const noexcept {
+      _function->operator()(track, index, static_cast<TrackChangeReason>(reason), transitionGapMs);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<TrackItem>& /* track */, double /* index */, TrackChangeReason /* reason */, std::optional<double> /* transitionGapMs */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double_ create_Func_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double__Wrapper wrap_Func_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double_(Func_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double_ value) noexcept {
+    return Func_void_std__optional_TrackItem__double_TrackChangeReason_std__optional_double__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const PlayerProgress& /* progress */)>
+  /**
+   * Specialized version of `std::function<void(const PlayerProgress&)>`.
+   */
+  using Func_void_PlayerProgress = std::function<void(const PlayerProgress& /* progress */)>;
+  /**
+   * Wrapper class for a `std::function<void(const PlayerProgress& / * progress * /)>`, this can be used from Swift.
+   */
+  class Func_void_PlayerProgress_Wrapper final {
+  public:
+    explicit Func_void_PlayerProgress_Wrapper(std::function<void(const PlayerProgress& /* progress */)>&& func): _function(std::make_unique<std::function<void(const PlayerProgress& /* progress */)>>(std::move(func))) {}
+    inline void call(PlayerProgress progress) const noexcept {
+      _function->operator()(progress);
+    }
+  private:
+    std::unique_ptr<std::function<void(const PlayerProgress& /* progress */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_PlayerProgress create_Func_void_PlayerProgress(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_PlayerProgress_Wrapper wrap_Func_void_PlayerProgress(Func_void_PlayerProgress value) noexcept {
+    return Func_void_PlayerProgress_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(double /* milestone */, double /* trackIndex */)>
+  /**
+   * Specialized version of `std::function<void(double, double)>`.
+   */
+  using Func_void_double_double = std::function<void(double /* milestone */, double /* trackIndex */)>;
+  /**
+   * Wrapper class for a `std::function<void(double / * milestone * /, double / * trackIndex * /)>`, this can be used from Swift.
+   */
+  class Func_void_double_double_Wrapper final {
+  public:
+    explicit Func_void_double_double_Wrapper(std::function<void(double /* milestone */, double /* trackIndex */)>&& func): _function(std::make_unique<std::function<void(double /* milestone */, double /* trackIndex */)>>(std::move(func))) {}
+    inline void call(double milestone, double trackIndex) const noexcept {
+      _function->operator()(milestone, trackIndex);
+    }
+  private:
+    std::unique_ptr<std::function<void(double /* milestone */, double /* trackIndex */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_double_double create_Func_void_double_double(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_double_double_Wrapper wrap_Func_void_double_double(Func_void_double_double value) noexcept {
+    return Func_void_double_double_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const PlaybackError& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const PlaybackError&)>`.
+   */
+  using Func_void_PlaybackError = std::function<void(const PlaybackError& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const PlaybackError& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_PlaybackError_Wrapper final {
+  public:
+    explicit Func_void_PlaybackError_Wrapper(std::function<void(const PlaybackError& /* error */)>&& func): _function(std::make_unique<std::function<void(const PlaybackError& /* error */)>>(std::move(func))) {}
+    inline void call(PlaybackError error) const noexcept {
+      _function->operator()(error);
+    }
+  private:
+    std::unique_ptr<std::function<void(const PlaybackError& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_PlaybackError create_Func_void_PlaybackError(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_PlaybackError_Wrapper wrap_Func_void_PlaybackError(Func_void_PlaybackError value) noexcept {
+    return Func_void_PlaybackError_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const SkipCapability& /* capability */)>
+  /**
+   * Specialized version of `std::function<void(const SkipCapability&)>`.
+   */
+  using Func_void_SkipCapability = std::function<void(const SkipCapability& /* capability */)>;
+  /**
+   * Wrapper class for a `std::function<void(const SkipCapability& / * capability * /)>`, this can be used from Swift.
+   */
+  class Func_void_SkipCapability_Wrapper final {
+  public:
+    explicit Func_void_SkipCapability_Wrapper(std::function<void(const SkipCapability& /* capability */)>&& func): _function(std::make_unique<std::function<void(const SkipCapability& /* capability */)>>(std::move(func))) {}
+    inline void call(SkipCapability capability) const noexcept {
+      _function->operator()(capability);
+    }
+  private:
+    std::unique_ptr<std::function<void(const SkipCapability& /* capability */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_SkipCapability create_Func_void_SkipCapability(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_SkipCapability_Wrapper wrap_Func_void_SkipCapability(Func_void_SkipCapability value) noexcept {
+    return Func_void_SkipCapability_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const SleepTimerState& /* state */)>
+  /**
+   * Specialized version of `std::function<void(const SleepTimerState&)>`.
+   */
+  using Func_void_SleepTimerState = std::function<void(const SleepTimerState& /* state */)>;
+  /**
+   * Wrapper class for a `std::function<void(const SleepTimerState& / * state * /)>`, this can be used from Swift.
+   */
+  class Func_void_SleepTimerState_Wrapper final {
+  public:
+    explicit Func_void_SleepTimerState_Wrapper(std::function<void(const SleepTimerState& /* state */)>&& func): _function(std::make_unique<std::function<void(const SleepTimerState& /* state */)>>(std::move(func))) {}
+    inline void call(SleepTimerState state) const noexcept {
+      _function->operator()(state);
+    }
+  private:
+    std::unique_ptr<std::function<void(const SleepTimerState& /* state */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_SleepTimerState create_Func_void_SleepTimerState(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_SleepTimerState_Wrapper wrap_Func_void_SleepTimerState(Func_void_SleepTimerState value) noexcept {
+    return Func_void_SleepTimerState_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(BufferState /* state */)>
+  /**
+   * Specialized version of `std::function<void(BufferState)>`.
+   */
+  using Func_void_BufferState = std::function<void(BufferState /* state */)>;
+  /**
+   * Wrapper class for a `std::function<void(BufferState / * state * /)>`, this can be used from Swift.
+   */
+  class Func_void_BufferState_Wrapper final {
+  public:
+    explicit Func_void_BufferState_Wrapper(std::function<void(BufferState /* state */)>&& func): _function(std::make_unique<std::function<void(BufferState /* state */)>>(std::move(func))) {}
+    inline void call(int state) const noexcept {
+      _function->operator()(static_cast<BufferState>(state));
+    }
+  private:
+    std::unique_ptr<std::function<void(BufferState /* state */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_BufferState create_Func_void_BufferState(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_BufferState_Wrapper wrap_Func_void_BufferState(Func_void_BufferState value) noexcept {
+    return Func_void_BufferState_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<SectionIcon>
+  /**
+   * Specialized version of `std::optional<SectionIcon>`.
+   */
+  using std__optional_SectionIcon_ = std::optional<SectionIcon>;
+  inline std::optional<SectionIcon> create_std__optional_SectionIcon_(const SectionIcon& value) noexcept {
+    return std::optional<SectionIcon>(value);
+  }
+  inline bool has_value_std__optional_SectionIcon_(const std::optional<SectionIcon>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline SectionIcon get_std__optional_SectionIcon_(const std::optional<SectionIcon>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::vector<BrowseItem>
+  /**
+   * Specialized version of `std::vector<BrowseItem>`.
+   */
+  using std__vector_BrowseItem_ = std::vector<BrowseItem>;
+  inline std::vector<BrowseItem> create_std__vector_BrowseItem_(size_t size) noexcept {
+    std::vector<BrowseItem> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::vector<BrowseSection>
+  /**
+   * Specialized version of `std::vector<BrowseSection>`.
+   */
+  using std__vector_BrowseSection_ = std::vector<BrowseSection>;
+  inline std::vector<BrowseSection> create_std__vector_BrowseSection_(size_t size) noexcept {
+    std::vector<BrowseSection> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<BrowseItem>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<BrowseItem>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_BrowseItem___ = std::shared_ptr<Promise<std::vector<BrowseItem>>>;
+  inline std::shared_ptr<Promise<std::vector<BrowseItem>>> create_std__shared_ptr_Promise_std__vector_BrowseItem___() noexcept {
+    return Promise<std::vector<BrowseItem>>::create();
+  }
+  inline PromiseHolder<std::vector<BrowseItem>> wrap_std__shared_ptr_Promise_std__vector_BrowseItem___(std::shared_ptr<Promise<std::vector<BrowseItem>>> promise) noexcept {
+    return PromiseHolder<std::vector<BrowseItem>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<BrowseItem>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<BrowseItem>&)>`.
+   */
+  using Func_void_std__vector_BrowseItem_ = std::function<void(const std::vector<BrowseItem>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<BrowseItem>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_BrowseItem__Wrapper final {
+  public:
+    explicit Func_void_std__vector_BrowseItem__Wrapper(std::function<void(const std::vector<BrowseItem>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<BrowseItem>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<BrowseItem> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<BrowseItem>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_BrowseItem_ create_Func_void_std__vector_BrowseItem_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_BrowseItem__Wrapper wrap_Func_void_std__vector_BrowseItem_(Func_void_std__vector_BrowseItem_ value) noexcept {
+    return Func_void_std__vector_BrowseItem__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>(const std::string& /* parentId */)>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>(const std::string&)>`.
+   */
+  using Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem______std__string = std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>(const std::string& /* parentId */)>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>(const std::string& / * parentId * /)>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem______std__string_Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem______std__string_Wrapper(std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>(const std::string& /* parentId */)>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>(const std::string& /* parentId */)>>(std::move(func))) {}
+    inline std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>> call(std::string parentId) const noexcept {
+      auto __result = _function->operator()(parentId);
+      return __result;
+    }
+  private:
+    std::unique_ptr<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>(const std::string& /* parentId */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem______std__string create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem______std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem______std__string_Wrapper wrap_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem______std__string(Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem______std__string value) noexcept {
+    return Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem______std__string_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>`.
+   */
+  using std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem_____ = std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>> create_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem_____() noexcept {
+    return Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>::create();
+  }
+  inline PromiseHolder<std::shared_ptr<Promise<std::vector<BrowseItem>>>> wrap_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_BrowseItem_____(std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<BrowseItem>>>>> promise) noexcept {
+    return PromiseHolder<std::shared_ptr<Promise<std::vector<BrowseItem>>>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<Promise<std::vector<BrowseItem>>>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::shared_ptr<Promise<std::vector<BrowseItem>>>&)>`.
+   */
+  using Func_void_std__shared_ptr_Promise_std__vector_BrowseItem___ = std::function<void(const std::shared_ptr<Promise<std::vector<BrowseItem>>>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::shared_ptr<Promise<std::vector<BrowseItem>>>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__shared_ptr_Promise_std__vector_BrowseItem____Wrapper final {
+  public:
+    explicit Func_void_std__shared_ptr_Promise_std__vector_BrowseItem____Wrapper(std::function<void(const std::shared_ptr<Promise<std::vector<BrowseItem>>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<Promise<std::vector<BrowseItem>>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::shared_ptr<Promise<std::vector<BrowseItem>>> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::shared_ptr<Promise<std::vector<BrowseItem>>>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__shared_ptr_Promise_std__vector_BrowseItem___ create_Func_void_std__shared_ptr_Promise_std__vector_BrowseItem___(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__shared_ptr_Promise_std__vector_BrowseItem____Wrapper wrap_Func_void_std__shared_ptr_Promise_std__vector_BrowseItem___(Func_void_std__shared_ptr_Promise_std__vector_BrowseItem___ value) noexcept {
+    return Func_void_std__shared_ptr_Promise_std__vector_BrowseItem____Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::vector<TrackItem>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<TrackItem>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_TrackItem___ = std::shared_ptr<Promise<std::vector<TrackItem>>>;
+  inline std::shared_ptr<Promise<std::vector<TrackItem>>> create_std__shared_ptr_Promise_std__vector_TrackItem___() noexcept {
+    return Promise<std::vector<TrackItem>>::create();
+  }
+  inline PromiseHolder<std::vector<TrackItem>> wrap_std__shared_ptr_Promise_std__vector_TrackItem___(std::shared_ptr<Promise<std::vector<TrackItem>>> promise) noexcept {
+    return PromiseHolder<std::vector<TrackItem>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<TrackItem>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<TrackItem>&)>`.
+   */
+  using Func_void_std__vector_TrackItem_ = std::function<void(const std::vector<TrackItem>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<TrackItem>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_TrackItem__Wrapper final {
+  public:
+    explicit Func_void_std__vector_TrackItem__Wrapper(std::function<void(const std::vector<TrackItem>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<TrackItem>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<TrackItem> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<TrackItem>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_TrackItem_ create_Func_void_std__vector_TrackItem_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_TrackItem__Wrapper wrap_Func_void_std__vector_TrackItem_(Func_void_std__vector_TrackItem_ value) noexcept {
+    return Func_void_std__vector_TrackItem__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<MediaSearchType>
+  /**
+   * Specialized version of `std::optional<MediaSearchType>`.
+   */
+  using std__optional_MediaSearchType_ = std::optional<MediaSearchType>;
+  inline std::optional<MediaSearchType> create_std__optional_MediaSearchType_(const MediaSearchType& value) noexcept {
+    return std::optional<MediaSearchType>(value);
+  }
+  inline bool has_value_std__optional_MediaSearchType_(const std::optional<MediaSearchType>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MediaSearchType get_std__optional_MediaSearchType_(const std::optional<MediaSearchType>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<MediaSearchOrigin>
+  /**
+   * Specialized version of `std::optional<MediaSearchOrigin>`.
+   */
+  using std__optional_MediaSearchOrigin_ = std::optional<MediaSearchOrigin>;
+  inline std::optional<MediaSearchOrigin> create_std__optional_MediaSearchOrigin_(const MediaSearchOrigin& value) noexcept {
+    return std::optional<MediaSearchOrigin>(value);
+  }
+  inline bool has_value_std__optional_MediaSearchOrigin_(const std::optional<MediaSearchOrigin>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MediaSearchOrigin get_std__optional_MediaSearchOrigin_(const std::optional<MediaSearchOrigin>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<MediaSearchReference>
+  /**
+   * Specialized version of `std::optional<MediaSearchReference>`.
+   */
+  using std__optional_MediaSearchReference_ = std::optional<MediaSearchReference>;
+  inline std::optional<MediaSearchReference> create_std__optional_MediaSearchReference_(const MediaSearchReference& value) noexcept {
+    return std::optional<MediaSearchReference>(value);
+  }
+  inline bool has_value_std__optional_MediaSearchReference_(const std::optional<MediaSearchReference>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MediaSearchReference get_std__optional_MediaSearchReference_(const std::optional<MediaSearchReference>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<MediaSearchRepeatMode>
+  /**
+   * Specialized version of `std::optional<MediaSearchRepeatMode>`.
+   */
+  using std__optional_MediaSearchRepeatMode_ = std::optional<MediaSearchRepeatMode>;
+  inline std::optional<MediaSearchRepeatMode> create_std__optional_MediaSearchRepeatMode_(const MediaSearchRepeatMode& value) noexcept {
+    return std::optional<MediaSearchRepeatMode>(value);
+  }
+  inline bool has_value_std__optional_MediaSearchRepeatMode_(const std::optional<MediaSearchRepeatMode>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MediaSearchRepeatMode get_std__optional_MediaSearchRepeatMode_(const std::optional<MediaSearchRepeatMode>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<MediaSearchReleaseDateRange>
+  /**
+   * Specialized version of `std::optional<MediaSearchReleaseDateRange>`.
+   */
+  using std__optional_MediaSearchReleaseDateRange_ = std::optional<MediaSearchReleaseDateRange>;
+  inline std::optional<MediaSearchReleaseDateRange> create_std__optional_MediaSearchReleaseDateRange_(const MediaSearchReleaseDateRange& value) noexcept {
+    return std::optional<MediaSearchReleaseDateRange>(value);
+  }
+  inline bool has_value_std__optional_MediaSearchReleaseDateRange_(const std::optional<MediaSearchReleaseDateRange>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MediaSearchReleaseDateRange get_std__optional_MediaSearchReleaseDateRange_(const std::optional<MediaSearchReleaseDateRange>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<MediaSearchQueueLocation>
+  /**
+   * Specialized version of `std::optional<MediaSearchQueueLocation>`.
+   */
+  using std__optional_MediaSearchQueueLocation_ = std::optional<MediaSearchQueueLocation>;
+  inline std::optional<MediaSearchQueueLocation> create_std__optional_MediaSearchQueueLocation_(const MediaSearchQueueLocation& value) noexcept {
+    return std::optional<MediaSearchQueueLocation>(value);
+  }
+  inline bool has_value_std__optional_MediaSearchQueueLocation_(const std::optional<MediaSearchQueueLocation>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline MediaSearchQueueLocation get_std__optional_MediaSearchQueueLocation_(const std::optional<MediaSearchQueueLocation>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const MediaSearchRequest& /* request */)>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const MediaSearchRequest&)>`.
+   */
+  using Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______MediaSearchRequest = std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const MediaSearchRequest& /* request */)>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const MediaSearchRequest& / * request * /)>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______MediaSearchRequest_Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______MediaSearchRequest_Wrapper(std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const MediaSearchRequest& /* request */)>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const MediaSearchRequest& /* request */)>>(std::move(func))) {}
+    inline std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>> call(MediaSearchRequest request) const noexcept {
+      auto __result = _function->operator()(request);
+      return __result;
+    }
+  private:
+    std::unique_ptr<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const MediaSearchRequest& /* request */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______MediaSearchRequest create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______MediaSearchRequest(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______MediaSearchRequest_Wrapper wrap_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______MediaSearchRequest(Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______MediaSearchRequest value) noexcept {
+    return Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______MediaSearchRequest_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>`.
+   */
+  using std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem_____ = std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>> create_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem_____() noexcept {
+    return Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>::create();
+  }
+  inline PromiseHolder<std::shared_ptr<Promise<std::vector<TrackItem>>>> wrap_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem_____(std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>> promise) noexcept {
+    return PromiseHolder<std::shared_ptr<Promise<std::vector<TrackItem>>>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<Promise<std::vector<TrackItem>>>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::shared_ptr<Promise<std::vector<TrackItem>>>&)>`.
+   */
+  using Func_void_std__shared_ptr_Promise_std__vector_TrackItem___ = std::function<void(const std::shared_ptr<Promise<std::vector<TrackItem>>>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::shared_ptr<Promise<std::vector<TrackItem>>>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__shared_ptr_Promise_std__vector_TrackItem____Wrapper final {
+  public:
+    explicit Func_void_std__shared_ptr_Promise_std__vector_TrackItem____Wrapper(std::function<void(const std::shared_ptr<Promise<std::vector<TrackItem>>>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<Promise<std::vector<TrackItem>>>& /* result */)>>(std::move(func))) {}
+    inline void call(std::shared_ptr<Promise<std::vector<TrackItem>>> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::shared_ptr<Promise<std::vector<TrackItem>>>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__shared_ptr_Promise_std__vector_TrackItem___ create_Func_void_std__shared_ptr_Promise_std__vector_TrackItem___(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__shared_ptr_Promise_std__vector_TrackItem____Wrapper wrap_Func_void_std__shared_ptr_Promise_std__vector_TrackItem___(Func_void_std__shared_ptr_Promise_std__vector_TrackItem___ value) noexcept {
+    return Func_void_std__shared_ptr_Promise_std__vector_TrackItem____Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const std::string& /* mediaId */)>
+  /**
+   * Specialized version of `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const std::string&)>`.
+   */
+  using Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______std__string = std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const std::string& /* mediaId */)>;
+  /**
+   * Wrapper class for a `std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const std::string& / * mediaId * /)>`, this can be used from Swift.
+   */
+  class Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______std__string_Wrapper final {
+  public:
+    explicit Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______std__string_Wrapper(std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const std::string& /* mediaId */)>&& func): _function(std::make_unique<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const std::string& /* mediaId */)>>(std::move(func))) {}
+    inline std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>> call(std::string mediaId) const noexcept {
+      auto __result = _function->operator()(mediaId);
+      return __result;
+    }
+  private:
+    std::unique_ptr<std::function<std::shared_ptr<Promise<std::shared_ptr<Promise<std::vector<TrackItem>>>>>(const std::string& /* mediaId */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______std__string create_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______std__string_Wrapper wrap_Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______std__string(Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______std__string value) noexcept {
+    return Func_std__shared_ptr_Promise_std__shared_ptr_Promise_std__vector_TrackItem______std__string_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::function<void(ServiceReadyReason /* reason */)>
+  /**
+   * Specialized version of `std::function<void(ServiceReadyReason)>`.
+   */
+  using Func_void_ServiceReadyReason = std::function<void(ServiceReadyReason /* reason */)>;
+  /**
+   * Wrapper class for a `std::function<void(ServiceReadyReason / * reason * /)>`, this can be used from Swift.
+   */
+  class Func_void_ServiceReadyReason_Wrapper final {
+  public:
+    explicit Func_void_ServiceReadyReason_Wrapper(std::function<void(ServiceReadyReason /* reason */)>&& func): _function(std::make_unique<std::function<void(ServiceReadyReason /* reason */)>>(std::move(func))) {}
+    inline void call(int reason) const noexcept {
+      _function->operator()(static_cast<ServiceReadyReason>(reason));
+    }
+  private:
+    std::unique_ptr<std::function<void(ServiceReadyReason /* reason */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_ServiceReadyReason create_Func_void_ServiceReadyReason(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_ServiceReadyReason_Wrapper wrap_Func_void_ServiceReadyReason(Func_void_ServiceReadyReason value) noexcept {
+    return Func_void_ServiceReadyReason_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const CacheStatus& /* status */)>
+  /**
+   * Specialized version of `std::function<void(const CacheStatus&)>`.
+   */
+  using Func_void_CacheStatus = std::function<void(const CacheStatus& /* status */)>;
+  /**
+   * Wrapper class for a `std::function<void(const CacheStatus& / * status * /)>`, this can be used from Swift.
+   */
+  class Func_void_CacheStatus_Wrapper final {
+  public:
+    explicit Func_void_CacheStatus_Wrapper(std::function<void(const CacheStatus& /* status */)>&& func): _function(std::make_unique<std::function<void(const CacheStatus& /* status */)>>(std::move(func))) {}
+    inline void call(CacheStatus status) const noexcept {
+      _function->operator()(status);
+    }
+  private:
+    std::unique_ptr<std::function<void(const CacheStatus& /* status */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_CacheStatus create_Func_void_CacheStatus(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_CacheStatus_Wrapper wrap_Func_void_CacheStatus(Func_void_CacheStatus value) noexcept {
+    return Func_void_CacheStatus_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, std::string>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, std::string>`.
+   * 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__std__string_ final {
+    std::variant<nitro::NullType, std::string> variant;
+    std__variant_nitro__NullType__std__string_(std::variant<nitro::NullType, std::string> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, std::string>() 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 std::string get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__std__string_ create_std__variant_nitro__NullType__std__string_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__std__string_(value);
+  }
+  inline std__variant_nitro__NullType__std__string_ create_std__variant_nitro__NullType__std__string_(const std::string& value) noexcept {
+    return std__variant_nitro__NullType__std__string_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, std::string>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, std::string>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__std__string__ = std::optional<std::variant<nitro::NullType, std::string>>;
+  inline std::optional<std::variant<nitro::NullType, std::string>> create_std__optional_std__variant_nitro__NullType__std__string__(const std::variant<nitro::NullType, std::string>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, std::string>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__std__string__(const std::optional<std::variant<nitro::NullType, std::string>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, std::string> get_std__optional_std__variant_nitro__NullType__std__string__(const std::optional<std::variant<nitro::NullType, std::string>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // 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_ final {
+    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<std::variant<nitro::NullType, double>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, double>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__double__ = std::optional<std::variant<nitro::NullType, double>>;
+  inline std::optional<std::variant<nitro::NullType, double>> create_std__optional_std__variant_nitro__NullType__double__(const std::variant<nitro::NullType, double>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, double>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__double__(const std::optional<std::variant<nitro::NullType, double>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, double> get_std__optional_std__variant_nitro__NullType__double__(const std::optional<std::variant<nitro::NullType, double>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<NowPlayingFormatIosExtras>
+  /**
+   * Specialized version of `std::optional<NowPlayingFormatIosExtras>`.
+   */
+  using std__optional_NowPlayingFormatIosExtras_ = std::optional<NowPlayingFormatIosExtras>;
+  inline std::optional<NowPlayingFormatIosExtras> create_std__optional_NowPlayingFormatIosExtras_(const NowPlayingFormatIosExtras& value) noexcept {
+    return std::optional<NowPlayingFormatIosExtras>(value);
+  }
+  inline bool has_value_std__optional_NowPlayingFormatIosExtras_(const std::optional<NowPlayingFormatIosExtras>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline NowPlayingFormatIosExtras get_std__optional_NowPlayingFormatIosExtras_(const std::optional<NowPlayingFormatIosExtras>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::optional<NowPlayingFormatAndroidExtras>
+  /**
+   * Specialized version of `std::optional<NowPlayingFormatAndroidExtras>`.
+   */
+  using std__optional_NowPlayingFormatAndroidExtras_ = std::optional<NowPlayingFormatAndroidExtras>;
+  inline std::optional<NowPlayingFormatAndroidExtras> create_std__optional_NowPlayingFormatAndroidExtras_(const NowPlayingFormatAndroidExtras& value) noexcept {
+    return std::optional<NowPlayingFormatAndroidExtras>(value);
+  }
+  inline bool has_value_std__optional_NowPlayingFormatAndroidExtras_(const std::optional<NowPlayingFormatAndroidExtras>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline NowPlayingFormatAndroidExtras get_std__optional_NowPlayingFormatAndroidExtras_(const std::optional<NowPlayingFormatAndroidExtras>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, NowPlayingFormat>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, NowPlayingFormat>`.
+   * 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__NowPlayingFormat_ final {
+    std::variant<nitro::NullType, NowPlayingFormat> variant;
+    std__variant_nitro__NullType__NowPlayingFormat_(std::variant<nitro::NullType, NowPlayingFormat> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, NowPlayingFormat>() 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 NowPlayingFormat get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__NowPlayingFormat_ create_std__variant_nitro__NullType__NowPlayingFormat_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__NowPlayingFormat_(value);
+  }
+  inline std__variant_nitro__NullType__NowPlayingFormat_ create_std__variant_nitro__NullType__NowPlayingFormat_(const NowPlayingFormat& value) noexcept {
+    return std__variant_nitro__NullType__NowPlayingFormat_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, NowPlayingFormat>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, NowPlayingFormat>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__NowPlayingFormat__ = std::optional<std::variant<nitro::NullType, NowPlayingFormat>>;
+  inline std::optional<std::variant<nitro::NullType, NowPlayingFormat>> create_std__optional_std__variant_nitro__NullType__NowPlayingFormat__(const std::variant<nitro::NullType, NowPlayingFormat>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, NowPlayingFormat>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__NowPlayingFormat__(const std::optional<std::variant<nitro::NullType, NowPlayingFormat>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, NowPlayingFormat> get_std__optional_std__variant_nitro__NullType__NowPlayingFormat__(const std::optional<std::variant<nitro::NullType, NowPlayingFormat>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::function<void(const std::optional<std::variant<nitro::NullType, NowPlayingFormat>>& /* format */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<std::variant<nitro::NullType, NowPlayingFormat>>&)>`.
+   */
+  using Func_void_std__optional_std__variant_nitro__NullType__NowPlayingFormat__ = std::function<void(const std::optional<std::variant<nitro::NullType, NowPlayingFormat>>& /* format */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<std::variant<nitro::NullType, NowPlayingFormat>>& / * format * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_std__variant_nitro__NullType__NowPlayingFormat___Wrapper final {
+  public:
+    explicit Func_void_std__optional_std__variant_nitro__NullType__NowPlayingFormat___Wrapper(std::function<void(const std::optional<std::variant<nitro::NullType, NowPlayingFormat>>& /* format */)>&& func): _function(std::make_unique<std::function<void(const std::optional<std::variant<nitro::NullType, NowPlayingFormat>>& /* format */)>>(std::move(func))) {}
+    inline void call(std::optional<std::variant<nitro::NullType, NowPlayingFormat>> format) const noexcept {
+      _function->operator()(format);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<std::variant<nitro::NullType, NowPlayingFormat>>& /* format */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__optional_std__variant_nitro__NullType__NowPlayingFormat__ create_Func_void_std__optional_std__variant_nitro__NullType__NowPlayingFormat__(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_std__variant_nitro__NullType__NowPlayingFormat___Wrapper wrap_Func_void_std__optional_std__variant_nitro__NullType__NowPlayingFormat__(Func_void_std__optional_std__variant_nitro__NullType__NowPlayingFormat__ value) noexcept {
+    return Func_void_std__optional_std__variant_nitro__NullType__NowPlayingFormat___Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridTrackPlayerSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridTrackPlayerSpec>`.
+   */
+  using std__shared_ptr_HybridTrackPlayerSpec_ = std::shared_ptr<HybridTrackPlayerSpec>;
+  std::shared_ptr<HybridTrackPlayerSpec> create_std__shared_ptr_HybridTrackPlayerSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridTrackPlayerSpec_(std__shared_ptr_HybridTrackPlayerSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridTrackPlayerSpec>
+  using std__weak_ptr_HybridTrackPlayerSpec_ = std::weak_ptr<HybridTrackPlayerSpec>;
+  inline std__weak_ptr_HybridTrackPlayerSpec_ weakify_std__shared_ptr_HybridTrackPlayerSpec_(const std::shared_ptr<HybridTrackPlayerSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<std::vector<TrackItem>>
+  using Result_std__vector_TrackItem__ = Result<std::vector<TrackItem>>;
+  inline Result_std__vector_TrackItem__ create_Result_std__vector_TrackItem__(const std::vector<TrackItem>& value) noexcept {
+    return Result<std::vector<TrackItem>>::withValue(value);
+  }
+  inline Result_std__vector_TrackItem__ create_Result_std__vector_TrackItem__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<TrackItem>>::withError(error);
+  }
+  
+  // pragma MARK: Result<PlaybackMode>
+  using Result_PlaybackMode_ = Result<PlaybackMode>;
+  inline Result_PlaybackMode_ create_Result_PlaybackMode_(const PlaybackMode& value) noexcept {
+    return Result<PlaybackMode>::withValue(value);
+  }
+  inline Result_PlaybackMode_ create_Result_PlaybackMode_(const std::exception_ptr& error) noexcept {
+    return Result<PlaybackMode>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<ShuffleResult>>>
+  using Result_std__shared_ptr_Promise_ShuffleResult___ = Result<std::shared_ptr<Promise<ShuffleResult>>>;
+  inline Result_std__shared_ptr_Promise_ShuffleResult___ create_Result_std__shared_ptr_Promise_ShuffleResult___(const std::shared_ptr<Promise<ShuffleResult>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<ShuffleResult>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_ShuffleResult___ create_Result_std__shared_ptr_Promise_ShuffleResult___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<ShuffleResult>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<PlayerState>
+  using Result_PlayerState_ = Result<PlayerState>;
+  inline Result_PlayerState_ create_Result_PlayerState_(PlayerState value) noexcept {
+    return Result<PlayerState>::withValue(std::move(value));
+  }
+  inline Result_PlayerState_ create_Result_PlayerState_(const std::exception_ptr& error) noexcept {
+    return Result<PlayerState>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<TrackSource>>
+  using Result_std__optional_TrackSource__ = Result<std::optional<TrackSource>>;
+  inline Result_std__optional_TrackSource__ create_Result_std__optional_TrackSource__(std::optional<TrackSource> value) noexcept {
+    return Result<std::optional<TrackSource>>::withValue(std::move(value));
+  }
+  inline Result_std__optional_TrackSource__ create_Result_std__optional_TrackSource__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<TrackSource>>::withError(error);
+  }
+  
+  // pragma MARK: Result<PitchCorrectionMode>
+  using Result_PitchCorrectionMode_ = Result<PitchCorrectionMode>;
+  inline Result_PitchCorrectionMode_ create_Result_PitchCorrectionMode_(PitchCorrectionMode value) noexcept {
+    return Result<PitchCorrectionMode>::withValue(std::move(value));
+  }
+  inline Result_PitchCorrectionMode_ create_Result_PitchCorrectionMode_(const std::exception_ptr& error) noexcept {
+    return Result<PitchCorrectionMode>::withError(error);
+  }
+  
+  // pragma MARK: Result<RemoteControlOptions>
+  using Result_RemoteControlOptions_ = Result<RemoteControlOptions>;
+  inline Result_RemoteControlOptions_ create_Result_RemoteControlOptions_(const RemoteControlOptions& value) noexcept {
+    return Result<RemoteControlOptions>::withValue(value);
+  }
+  inline Result_RemoteControlOptions_ create_Result_RemoteControlOptions_(const std::exception_ptr& error) noexcept {
+    return Result<RemoteControlOptions>::withError(error);
+  }
+  
+  // pragma MARK: Result<BufferState>
+  using Result_BufferState_ = Result<BufferState>;
+  inline Result_BufferState_ create_Result_BufferState_(BufferState value) noexcept {
+    return Result<BufferState>::withValue(std::move(value));
+  }
+  inline Result_BufferState_ create_Result_BufferState_(const std::exception_ptr& error) noexcept {
+    return Result<BufferState>::withError(error);
+  }
+  
+  // pragma MARK: Result<SkipCapability>
+  using Result_SkipCapability_ = Result<SkipCapability>;
+  inline Result_SkipCapability_ create_Result_SkipCapability_(const SkipCapability& value) noexcept {
+    return Result<SkipCapability>::withValue(value);
+  }
+  inline Result_SkipCapability_ create_Result_SkipCapability_(const std::exception_ptr& error) noexcept {
+    return Result<SkipCapability>::withError(error);
+  }
+  
+  // pragma MARK: Result<SleepTimerState>
+  using Result_SleepTimerState_ = Result<SleepTimerState>;
+  inline Result_SleepTimerState_ create_Result_SleepTimerState_(const SleepTimerState& value) noexcept {
+    return Result<SleepTimerState>::withValue(value);
+  }
+  inline Result_SleepTimerState_ create_Result_SleepTimerState_(const std::exception_ptr& error) noexcept {
+    return Result<SleepTimerState>::withError(error);
+  }
+  
+  // 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<CacheStatus>
+  using Result_CacheStatus_ = Result<CacheStatus>;
+  inline Result_CacheStatus_ create_Result_CacheStatus_(const CacheStatus& value) noexcept {
+    return Result<CacheStatus>::withValue(value);
+  }
+  inline Result_CacheStatus_ create_Result_CacheStatus_(const std::exception_ptr& error) noexcept {
+    return Result<CacheStatus>::withError(error);
+  }
+  
+  // pragma MARK: Result<ReplayGainMode>
+  using Result_ReplayGainMode_ = Result<ReplayGainMode>;
+  inline Result_ReplayGainMode_ create_Result_ReplayGainMode_(ReplayGainMode value) noexcept {
+    return Result<ReplayGainMode>::withValue(std::move(value));
+  }
+  inline Result_ReplayGainMode_ create_Result_ReplayGainMode_(const std::exception_ptr& error) noexcept {
+    return Result<ReplayGainMode>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::variant<nitro::NullType, NowPlayingFormat>>
+  using Result_std__variant_nitro__NullType__NowPlayingFormat__ = Result<std::variant<nitro::NullType, NowPlayingFormat>>;
+  inline Result_std__variant_nitro__NullType__NowPlayingFormat__ create_Result_std__variant_nitro__NullType__NowPlayingFormat__(const std::variant<nitro::NullType, NowPlayingFormat>& value) noexcept {
+    return Result<std::variant<nitro::NullType, NowPlayingFormat>>::withValue(value);
+  }
+  inline Result_std__variant_nitro__NullType__NowPlayingFormat__ create_Result_std__variant_nitro__NullType__NowPlayingFormat__(const std::exception_ptr& error) noexcept {
+    return Result<std::variant<nitro::NullType, NowPlayingFormat>>::withError(error);
+  }
+  
+  // pragma MARK: std::optional<std::shared_ptr<ArrayBuffer>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<ArrayBuffer>>`.
+   */
+  using std__optional_std__shared_ptr_ArrayBuffer__ = std::optional<std::shared_ptr<ArrayBuffer>>;
+  inline std::optional<std::shared_ptr<ArrayBuffer>> create_std__optional_std__shared_ptr_ArrayBuffer__(const std::shared_ptr<ArrayBuffer>& value) noexcept {
+    return std::optional<std::shared_ptr<ArrayBuffer>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_ArrayBuffer__(const std::optional<std::shared_ptr<ArrayBuffer>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<ArrayBuffer> get_std__optional_std__shared_ptr_ArrayBuffer__(const std::optional<std::shared_ptr<ArrayBuffer>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::function<void(const VisualizerFrame& /* frame */)>
+  /**
+   * Specialized version of `std::function<void(const VisualizerFrame&)>`.
+   */
+  using Func_void_VisualizerFrame = std::function<void(const VisualizerFrame& /* frame */)>;
+  /**
+   * Wrapper class for a `std::function<void(const VisualizerFrame& / * frame * /)>`, this can be used from Swift.
+   */
+  class Func_void_VisualizerFrame_Wrapper final {
+  public:
+    explicit Func_void_VisualizerFrame_Wrapper(std::function<void(const VisualizerFrame& /* frame */)>&& func): _function(std::make_unique<std::function<void(const VisualizerFrame& /* frame */)>>(std::move(func))) {}
+    inline void call(VisualizerFrame frame) const noexcept {
+      _function->operator()(frame);
+    }
+  private:
+    std::unique_ptr<std::function<void(const VisualizerFrame& /* frame */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_VisualizerFrame create_Func_void_VisualizerFrame(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_VisualizerFrame_Wrapper wrap_Func_void_VisualizerFrame(Func_void_VisualizerFrame value) noexcept {
+    return Func_void_VisualizerFrame_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(VisualizerErrorReason /* reason */)>
+  /**
+   * Specialized version of `std::function<void(VisualizerErrorReason)>`.
+   */
+  using Func_void_VisualizerErrorReason = std::function<void(VisualizerErrorReason /* reason */)>;
+  /**
+   * Wrapper class for a `std::function<void(VisualizerErrorReason / * reason * /)>`, this can be used from Swift.
+   */
+  class Func_void_VisualizerErrorReason_Wrapper final {
+  public:
+    explicit Func_void_VisualizerErrorReason_Wrapper(std::function<void(VisualizerErrorReason /* reason */)>&& func): _function(std::make_unique<std::function<void(VisualizerErrorReason /* reason */)>>(std::move(func))) {}
+    inline void call(int reason) const noexcept {
+      _function->operator()(static_cast<VisualizerErrorReason>(reason));
+    }
+  private:
+    std::unique_ptr<std::function<void(VisualizerErrorReason /* reason */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_VisualizerErrorReason create_Func_void_VisualizerErrorReason(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_VisualizerErrorReason_Wrapper wrap_Func_void_VisualizerErrorReason(Func_void_VisualizerErrorReason value) noexcept {
+    return Func_void_VisualizerErrorReason_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridVisualizerSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridVisualizerSpec>`.
+   */
+  using std__shared_ptr_HybridVisualizerSpec_ = std::shared_ptr<HybridVisualizerSpec>;
+  std::shared_ptr<HybridVisualizerSpec> create_std__shared_ptr_HybridVisualizerSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridVisualizerSpec_(std__shared_ptr_HybridVisualizerSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridVisualizerSpec>
+  using std__weak_ptr_HybridVisualizerSpec_ = std::weak_ptr<HybridVisualizerSpec>;
+  inline std__weak_ptr_HybridVisualizerSpec_ weakify_std__shared_ptr_HybridVisualizerSpec_(const std::shared_ptr<HybridVisualizerSpec>& strong) noexcept { return strong; }
+
+} // namespace margelo::nitro::queueplayer::bridge::swift