react-native-nitro-player 0.3.0-alpha.9 → 0.4.0

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

@@ -8,20 +8,60 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `CurrentPlayingType` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class CurrentPlayingType; }
+// Forward declaration of `DownloadConfig` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadConfig; }
+// Forward declaration of `DownloadErrorReason` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class DownloadErrorReason; }
+// Forward declaration of `DownloadError` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadError; }
+// Forward declaration of `DownloadProgress` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadProgress; }
+// Forward declaration of `DownloadQueueStatus` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadQueueStatus; }
+// Forward declaration of `DownloadState` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class DownloadState; }
+// Forward declaration of `DownloadStorageInfo` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadStorageInfo; }
+// Forward declaration of `DownloadTask` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadTask; }
+// Forward declaration of `DownloadedPlaylist` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadedPlaylist; }
+// Forward declaration of `DownloadedTrack` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct DownloadedTrack; }
+// Forward declaration of `EqualizerBand` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct EqualizerBand; }
+// Forward declaration of `EqualizerPreset` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct EqualizerPreset; }
+// Forward declaration of `EqualizerState` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct EqualizerState; }
+// Forward declaration of `GainRange` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { struct GainRange; }
 // Forward declaration of `HybridAudioRoutePickerSpec` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { class HybridAudioRoutePickerSpec; }
+// Forward declaration of `HybridDownloadManagerSpec` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { class HybridDownloadManagerSpec; }
+// Forward declaration of `HybridEqualizerSpec` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { class HybridEqualizerSpec; }
 // Forward declaration of `HybridPlayerQueueSpec` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { class HybridPlayerQueueSpec; }
 // Forward declaration of `HybridTrackPlayerSpec` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { class HybridTrackPlayerSpec; }
+// Forward declaration of `PlaybackSource` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class PlaybackSource; }
 // Forward declaration of `PlayerState` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct PlayerState; }
 // Forward declaration of `Playlist` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct Playlist; }
+// Forward declaration of `PresetType` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class PresetType; }
 // Forward declaration of `QueueOperation` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 // Forward declaration of `Reason` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { enum class Reason; }
+// Forward declaration of `StorageLocation` to properly resolve imports.
+namespace margelo::nitro::nitroplayer { enum class StorageLocation; }
 // Forward declaration of `TrackItem` to properly resolve imports.
 namespace margelo::nitro::nitroplayer { struct TrackItem; }
 // Forward declaration of `TrackPlayerState` to properly resolve imports.
@@ -30,22 +70,49 @@ namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
 // Forward declarations of Swift defined types
 // Forward declaration of `HybridAudioRoutePickerSpec_cxx` to properly resolve imports.
 namespace NitroPlayer { class HybridAudioRoutePickerSpec_cxx; }
+// Forward declaration of `HybridDownloadManagerSpec_cxx` to properly resolve imports.
+namespace NitroPlayer { class HybridDownloadManagerSpec_cxx; }
+// Forward declaration of `HybridEqualizerSpec_cxx` to properly resolve imports.
+namespace NitroPlayer { class HybridEqualizerSpec_cxx; }
 // Forward declaration of `HybridPlayerQueueSpec_cxx` to properly resolve imports.
 namespace NitroPlayer { class HybridPlayerQueueSpec_cxx; }
 // Forward declaration of `HybridTrackPlayerSpec_cxx` to properly resolve imports.
 namespace NitroPlayer { class HybridTrackPlayerSpec_cxx; }
 
 // Include C++ defined types
+#include "CurrentPlayingType.hpp"
+#include "DownloadConfig.hpp"
+#include "DownloadError.hpp"
+#include "DownloadErrorReason.hpp"
+#include "DownloadProgress.hpp"
+#include "DownloadQueueStatus.hpp"
+#include "DownloadState.hpp"
+#include "DownloadStorageInfo.hpp"
+#include "DownloadTask.hpp"
+#include "DownloadedPlaylist.hpp"
+#include "DownloadedTrack.hpp"
+#include "EqualizerBand.hpp"
+#include "EqualizerPreset.hpp"
+#include "EqualizerState.hpp"
+#include "GainRange.hpp"
 #include "HybridAudioRoutePickerSpec.hpp"
+#include "HybridDownloadManagerSpec.hpp"
+#include "HybridEqualizerSpec.hpp"
 #include "HybridPlayerQueueSpec.hpp"
 #include "HybridTrackPlayerSpec.hpp"
+#include "PlaybackSource.hpp"
 #include "PlayerState.hpp"
 #include "Playlist.hpp"
+#include "PresetType.hpp"
 #include "QueueOperation.hpp"
 #include "Reason.hpp"
+#include "StorageLocation.hpp"
 #include "TrackItem.hpp"
 #include "TrackPlayerState.hpp"
+#include <NitroModules/AnyMap.hpp>
 #include <NitroModules/Null.hpp>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
 #include <functional>
@@ -82,74 +149,913 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
     return Result<void>::withError(error);
   }
   
+  // pragma MARK: std::optional<StorageLocation>
+  /**
+   * Specialized version of `std::optional<StorageLocation>`.
+   */
+  using std__optional_StorageLocation_ = std::optional<StorageLocation>;
+  inline std::optional<StorageLocation> create_std__optional_StorageLocation_(const StorageLocation& value) noexcept {
+    return std::optional<StorageLocation>(value);
+  }
+  inline bool has_value_std__optional_StorageLocation_(const std::optional<StorageLocation>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline StorageLocation get_std__optional_StorageLocation_(const std::optional<StorageLocation>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<double>
+  /**
+   * Specialized version of `std::optional<double>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
+    return std::optional<double>(value);
+  }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
+  }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::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_ {
+    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;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::string>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::string>>`.
+   */
+  using std__shared_ptr_Promise_std__string__ = std::shared_ptr<Promise<std::string>>;
+  inline std::shared_ptr<Promise<std::string>> create_std__shared_ptr_Promise_std__string__() noexcept {
+    return Promise<std::string>::create();
+  }
+  inline PromiseHolder<std::string> wrap_std__shared_ptr_Promise_std__string__(std::shared_ptr<Promise<std::string>> promise) noexcept {
+    return PromiseHolder<std::string>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::string& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::string&)>`.
+   */
+  using Func_void_std__string = std::function<void(const std::string& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::string& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__string_Wrapper final {
+  public:
+    explicit Func_void_std__string_Wrapper(std::function<void(const std::string& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* result */)>>(std::move(func))) {}
+    inline void call(std::string result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::string& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__string create_Func_void_std__string(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__string_Wrapper wrap_Func_void_std__string(Func_void_std__string value) noexcept {
+    return Func_void_std__string_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const std::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<std::shared_ptr<AnyMap>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<AnyMap>>`.
+   */
+  using std__optional_std__shared_ptr_AnyMap__ = std::optional<std::shared_ptr<AnyMap>>;
+  inline std::optional<std::shared_ptr<AnyMap>> create_std__optional_std__shared_ptr_AnyMap__(const std::shared_ptr<AnyMap>& value) noexcept {
+    return std::optional<std::shared_ptr<AnyMap>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_AnyMap__(const std::optional<std::shared_ptr<AnyMap>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<AnyMap> get_std__optional_std__shared_ptr_AnyMap__(const std::optional<std::shared_ptr<AnyMap>>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::optional<std::string>
   /**
-   * Specialized version of `std::optional<std::string>`.
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::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::shared_ptr<Promise<std::vector<std::string>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::vector<std::string>>>`.
+   */
+  using std__shared_ptr_Promise_std__vector_std__string___ = std::shared_ptr<Promise<std::vector<std::string>>>;
+  inline std::shared_ptr<Promise<std::vector<std::string>>> create_std__shared_ptr_Promise_std__vector_std__string___() noexcept {
+    return Promise<std::vector<std::string>>::create();
+  }
+  inline PromiseHolder<std::vector<std::string>> wrap_std__shared_ptr_Promise_std__vector_std__string___(std::shared_ptr<Promise<std::vector<std::string>>> promise) noexcept {
+    return PromiseHolder<std::vector<std::string>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::vector<std::string>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::vector<std::string>&)>`.
+   */
+  using Func_void_std__vector_std__string_ = std::function<void(const std::vector<std::string>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::vector<std::string>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__vector_std__string__Wrapper final {
+  public:
+    explicit Func_void_std__vector_std__string__Wrapper(std::function<void(const std::vector<std::string>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::vector<std::string>& /* result */)>>(std::move(func))) {}
+    inline void call(std::vector<std::string> result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::vector<std::string>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__vector_std__string_ create_Func_void_std__vector_std__string_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__vector_std__string__Wrapper wrap_Func_void_std__vector_std__string_(Func_void_std__vector_std__string_ value) noexcept {
+    return Func_void_std__vector_std__string__Wrapper(std::move(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::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::variant<nitro::NullType, double>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, double>`.
+   * std::variant cannot be used in Swift because of a Swift bug.
+   * Not even specializing it works. So we create a wrapper struct.
+   */
+  struct std__variant_nitro__NullType__double_ {
+    std::variant<nitro::NullType, double> variant;
+    std__variant_nitro__NullType__double_(std::variant<nitro::NullType, double> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, double>() const noexcept {
+      return variant;
+    }
+    inline size_t index() const noexcept {
+      return variant.index();
+    }
+    inline nitro::NullType get_0() const noexcept {
+      return std::get<0>(variant);
+    }
+    inline double get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__double_ create_std__variant_nitro__NullType__double_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__double_(value);
+  }
+  inline std__variant_nitro__NullType__double_ create_std__variant_nitro__NullType__double_(double value) noexcept {
+    return std__variant_nitro__NullType__double_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, double>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, double>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__double__ = std::optional<std::variant<nitro::NullType, double>>;
+  inline std::optional<std::variant<nitro::NullType, double>> create_std__optional_std__variant_nitro__NullType__double__(const std::variant<nitro::NullType, double>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, double>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__double__(const std::optional<std::variant<nitro::NullType, double>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, double> get_std__optional_std__variant_nitro__NullType__double__(const std::optional<std::variant<nitro::NullType, double>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, DownloadError>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, DownloadError>`.
+   * 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__DownloadError_ {
+    std::variant<nitro::NullType, DownloadError> variant;
+    std__variant_nitro__NullType__DownloadError_(std::variant<nitro::NullType, DownloadError> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, DownloadError>() 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 DownloadError get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__DownloadError_ create_std__variant_nitro__NullType__DownloadError_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__DownloadError_(value);
+  }
+  inline std__variant_nitro__NullType__DownloadError_ create_std__variant_nitro__NullType__DownloadError_(const DownloadError& value) noexcept {
+    return std__variant_nitro__NullType__DownloadError_(value);
+  }
+  
+  // pragma MARK: std::optional<std::variant<nitro::NullType, DownloadError>>
+  /**
+   * Specialized version of `std::optional<std::variant<nitro::NullType, DownloadError>>`.
+   */
+  using std__optional_std__variant_nitro__NullType__DownloadError__ = std::optional<std::variant<nitro::NullType, DownloadError>>;
+  inline std::optional<std::variant<nitro::NullType, DownloadError>> create_std__optional_std__variant_nitro__NullType__DownloadError__(const std::variant<nitro::NullType, DownloadError>& value) noexcept {
+    return std::optional<std::variant<nitro::NullType, DownloadError>>(value);
+  }
+  inline bool has_value_std__optional_std__variant_nitro__NullType__DownloadError__(const std::optional<std::variant<nitro::NullType, DownloadError>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::variant<nitro::NullType, DownloadError> get_std__optional_std__variant_nitro__NullType__DownloadError__(const std::optional<std::variant<nitro::NullType, DownloadError>>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, DownloadTask>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, DownloadTask>`.
+   * 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__DownloadTask_ {
+    std::variant<nitro::NullType, DownloadTask> variant;
+    std__variant_nitro__NullType__DownloadTask_(std::variant<nitro::NullType, DownloadTask> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, DownloadTask>() 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 DownloadTask get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__DownloadTask_ create_std__variant_nitro__NullType__DownloadTask_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__DownloadTask_(value);
+  }
+  inline std__variant_nitro__NullType__DownloadTask_ create_std__variant_nitro__NullType__DownloadTask_(const DownloadTask& value) noexcept {
+    return std__variant_nitro__NullType__DownloadTask_(value);
+  }
+  
+  // pragma MARK: std::vector<DownloadTask>
+  /**
+   * Specialized version of `std::vector<DownloadTask>`.
+   */
+  using std__vector_DownloadTask_ = std::vector<DownloadTask>;
+  inline std::vector<DownloadTask> create_std__vector_DownloadTask_(size_t size) noexcept {
+    std::vector<DownloadTask> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, DownloadedTrack>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, DownloadedTrack>`.
+   * 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__DownloadedTrack_ {
+    std::variant<nitro::NullType, DownloadedTrack> variant;
+    std__variant_nitro__NullType__DownloadedTrack_(std::variant<nitro::NullType, DownloadedTrack> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, DownloadedTrack>() 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 DownloadedTrack get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__DownloadedTrack_ create_std__variant_nitro__NullType__DownloadedTrack_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__DownloadedTrack_(value);
+  }
+  inline std__variant_nitro__NullType__DownloadedTrack_ create_std__variant_nitro__NullType__DownloadedTrack_(const DownloadedTrack& value) noexcept {
+    return std__variant_nitro__NullType__DownloadedTrack_(value);
+  }
+  
+  // pragma MARK: std::vector<DownloadedTrack>
+  /**
+   * Specialized version of `std::vector<DownloadedTrack>`.
+   */
+  using std__vector_DownloadedTrack_ = std::vector<DownloadedTrack>;
+  inline std::vector<DownloadedTrack> create_std__vector_DownloadedTrack_(size_t size) noexcept {
+    std::vector<DownloadedTrack> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::variant<nitro::NullType, DownloadedPlaylist>
+  /**
+   * Wrapper struct for `std::variant<nitro::NullType, DownloadedPlaylist>`.
+   * 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__DownloadedPlaylist_ {
+    std::variant<nitro::NullType, DownloadedPlaylist> variant;
+    std__variant_nitro__NullType__DownloadedPlaylist_(std::variant<nitro::NullType, DownloadedPlaylist> variant): variant(variant) { }
+    operator std::variant<nitro::NullType, DownloadedPlaylist>() 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 DownloadedPlaylist get_1() const noexcept {
+      return std::get<1>(variant);
+    }
+  };
+  inline std__variant_nitro__NullType__DownloadedPlaylist_ create_std__variant_nitro__NullType__DownloadedPlaylist_(nitro::NullType value) noexcept {
+    return std__variant_nitro__NullType__DownloadedPlaylist_(value);
+  }
+  inline std__variant_nitro__NullType__DownloadedPlaylist_ create_std__variant_nitro__NullType__DownloadedPlaylist_(const DownloadedPlaylist& value) noexcept {
+    return std__variant_nitro__NullType__DownloadedPlaylist_(value);
+  }
+  
+  // pragma MARK: std::vector<DownloadedPlaylist>
+  /**
+   * Specialized version of `std::vector<DownloadedPlaylist>`.
+   */
+  using std__vector_DownloadedPlaylist_ = std::vector<DownloadedPlaylist>;
+  inline std::vector<DownloadedPlaylist> create_std__vector_DownloadedPlaylist_(size_t size) noexcept {
+    std::vector<DownloadedPlaylist> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<DownloadStorageInfo>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<DownloadStorageInfo>>`.
+   */
+  using std__shared_ptr_Promise_DownloadStorageInfo__ = std::shared_ptr<Promise<DownloadStorageInfo>>;
+  inline std::shared_ptr<Promise<DownloadStorageInfo>> create_std__shared_ptr_Promise_DownloadStorageInfo__() noexcept {
+    return Promise<DownloadStorageInfo>::create();
+  }
+  inline PromiseHolder<DownloadStorageInfo> wrap_std__shared_ptr_Promise_DownloadStorageInfo__(std::shared_ptr<Promise<DownloadStorageInfo>> promise) noexcept {
+    return PromiseHolder<DownloadStorageInfo>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const DownloadStorageInfo& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const DownloadStorageInfo&)>`.
+   */
+  using Func_void_DownloadStorageInfo = std::function<void(const DownloadStorageInfo& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const DownloadStorageInfo& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_DownloadStorageInfo_Wrapper final {
+  public:
+    explicit Func_void_DownloadStorageInfo_Wrapper(std::function<void(const DownloadStorageInfo& /* result */)>&& func): _function(std::make_unique<std::function<void(const DownloadStorageInfo& /* result */)>>(std::move(func))) {}
+    inline void call(DownloadStorageInfo result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const DownloadStorageInfo& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_DownloadStorageInfo create_Func_void_DownloadStorageInfo(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_DownloadStorageInfo_Wrapper wrap_Func_void_DownloadStorageInfo(Func_void_DownloadStorageInfo value) noexcept {
+    return Func_void_DownloadStorageInfo_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const DownloadProgress& /* progress */)>
+  /**
+   * Specialized version of `std::function<void(const DownloadProgress&)>`.
+   */
+  using Func_void_DownloadProgress = std::function<void(const DownloadProgress& /* progress */)>;
+  /**
+   * Wrapper class for a `std::function<void(const DownloadProgress& / * progress * /)>`, this can be used from Swift.
+   */
+  class Func_void_DownloadProgress_Wrapper final {
+  public:
+    explicit Func_void_DownloadProgress_Wrapper(std::function<void(const DownloadProgress& /* progress */)>&& func): _function(std::make_unique<std::function<void(const DownloadProgress& /* progress */)>>(std::move(func))) {}
+    inline void call(DownloadProgress progress) const noexcept {
+      _function->operator()(progress);
+    }
+  private:
+    std::unique_ptr<std::function<void(const DownloadProgress& /* progress */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_DownloadProgress create_Func_void_DownloadProgress(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_DownloadProgress_Wrapper wrap_Func_void_DownloadProgress(Func_void_DownloadProgress value) noexcept {
+    return Func_void_DownloadProgress_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::optional<DownloadError>
+  /**
+   * Specialized version of `std::optional<DownloadError>`.
+   */
+  using std__optional_DownloadError_ = std::optional<DownloadError>;
+  inline std::optional<DownloadError> create_std__optional_DownloadError_(const DownloadError& value) noexcept {
+    return std::optional<DownloadError>(value);
+  }
+  inline bool has_value_std__optional_DownloadError_(const std::optional<DownloadError>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline DownloadError get_std__optional_DownloadError_(const std::optional<DownloadError>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::function<void(const std::string& /* downloadId */, const std::string& /* trackId */, DownloadState /* state */, const std::optional<DownloadError>& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const std::string&, const std::string&, DownloadState, const std::optional<DownloadError>&)>`.
+   */
+  using Func_void_std__string_std__string_DownloadState_std__optional_DownloadError_ = std::function<void(const std::string& /* downloadId */, const std::string& /* trackId */, DownloadState /* state */, const std::optional<DownloadError>& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::string& / * downloadId * /, const std::string& / * trackId * /, DownloadState / * state * /, const std::optional<DownloadError>& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__string_std__string_DownloadState_std__optional_DownloadError__Wrapper final {
+  public:
+    explicit Func_void_std__string_std__string_DownloadState_std__optional_DownloadError__Wrapper(std::function<void(const std::string& /* downloadId */, const std::string& /* trackId */, DownloadState /* state */, const std::optional<DownloadError>& /* error */)>&& func): _function(std::make_unique<std::function<void(const std::string& /* downloadId */, const std::string& /* trackId */, DownloadState /* state */, const std::optional<DownloadError>& /* error */)>>(std::move(func))) {}
+    inline void call(std::string downloadId, std::string trackId, int state, std::optional<DownloadError> error) const noexcept {
+      _function->operator()(downloadId, trackId, static_cast<DownloadState>(state), error);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::string& /* downloadId */, const std::string& /* trackId */, DownloadState /* state */, const std::optional<DownloadError>& /* error */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__string_std__string_DownloadState_std__optional_DownloadError_ create_Func_void_std__string_std__string_DownloadState_std__optional_DownloadError_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__string_std__string_DownloadState_std__optional_DownloadError__Wrapper wrap_Func_void_std__string_std__string_DownloadState_std__optional_DownloadError_(Func_void_std__string_std__string_DownloadState_std__optional_DownloadError_ value) noexcept {
+    return Func_void_std__string_std__string_DownloadState_std__optional_DownloadError__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::function<void(const DownloadedTrack& /* downloadedTrack */)>
+  /**
+   * Specialized version of `std::function<void(const DownloadedTrack&)>`.
+   */
+  using Func_void_DownloadedTrack = std::function<void(const DownloadedTrack& /* downloadedTrack */)>;
+  /**
+   * Wrapper class for a `std::function<void(const DownloadedTrack& / * downloadedTrack * /)>`, this can be used from Swift.
+   */
+  class Func_void_DownloadedTrack_Wrapper final {
+  public:
+    explicit Func_void_DownloadedTrack_Wrapper(std::function<void(const DownloadedTrack& /* downloadedTrack */)>&& func): _function(std::make_unique<std::function<void(const DownloadedTrack& /* downloadedTrack */)>>(std::move(func))) {}
+    inline void call(DownloadedTrack downloadedTrack) const noexcept {
+      _function->operator()(downloadedTrack);
+    }
+  private:
+    std::unique_ptr<std::function<void(const DownloadedTrack& /* downloadedTrack */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_DownloadedTrack create_Func_void_DownloadedTrack(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_DownloadedTrack_Wrapper wrap_Func_void_DownloadedTrack(Func_void_DownloadedTrack value) noexcept {
+    return Func_void_DownloadedTrack_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<HybridDownloadManagerSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridDownloadManagerSpec>`.
+   */
+  using std__shared_ptr_HybridDownloadManagerSpec_ = std::shared_ptr<HybridDownloadManagerSpec>;
+  std::shared_ptr<HybridDownloadManagerSpec> create_std__shared_ptr_HybridDownloadManagerSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridDownloadManagerSpec_(std__shared_ptr_HybridDownloadManagerSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridDownloadManagerSpec>
+  using std__weak_ptr_HybridDownloadManagerSpec_ = std::weak_ptr<HybridDownloadManagerSpec>;
+  inline std__weak_ptr_HybridDownloadManagerSpec_ weakify_std__shared_ptr_HybridDownloadManagerSpec_(const std::shared_ptr<HybridDownloadManagerSpec>& strong) noexcept { return strong; }
+  
+  // pragma MARK: Result<DownloadConfig>
+  using Result_DownloadConfig_ = Result<DownloadConfig>;
+  inline Result_DownloadConfig_ create_Result_DownloadConfig_(const DownloadConfig& value) noexcept {
+    return Result<DownloadConfig>::withValue(value);
+  }
+  inline Result_DownloadConfig_ create_Result_DownloadConfig_(const std::exception_ptr& error) noexcept {
+    return Result<DownloadConfig>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::string>>>
+  using Result_std__shared_ptr_Promise_std__string___ = Result<std::shared_ptr<Promise<std::string>>>;
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::shared_ptr<Promise<std::string>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::string>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__string___ create_Result_std__shared_ptr_Promise_std__string___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::string>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<std::string>>>>
+  using Result_std__shared_ptr_Promise_std__vector_std__string____ = Result<std::shared_ptr<Promise<std::vector<std::string>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_std__string____ create_Result_std__shared_ptr_Promise_std__vector_std__string____(const std::shared_ptr<Promise<std::vector<std::string>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<std::string>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__vector_std__string____ create_Result_std__shared_ptr_Promise_std__vector_std__string____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<std::string>>>>::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<std::variant<nitro::NullType, DownloadTask>>
+  using Result_std__variant_nitro__NullType__DownloadTask__ = Result<std::variant<nitro::NullType, DownloadTask>>;
+  inline Result_std__variant_nitro__NullType__DownloadTask__ create_Result_std__variant_nitro__NullType__DownloadTask__(const std::variant<nitro::NullType, DownloadTask>& value) noexcept {
+    return Result<std::variant<nitro::NullType, DownloadTask>>::withValue(value);
+  }
+  inline Result_std__variant_nitro__NullType__DownloadTask__ create_Result_std__variant_nitro__NullType__DownloadTask__(const std::exception_ptr& error) noexcept {
+    return Result<std::variant<nitro::NullType, DownloadTask>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::vector<DownloadTask>>
+  using Result_std__vector_DownloadTask__ = Result<std::vector<DownloadTask>>;
+  inline Result_std__vector_DownloadTask__ create_Result_std__vector_DownloadTask__(const std::vector<DownloadTask>& value) noexcept {
+    return Result<std::vector<DownloadTask>>::withValue(value);
+  }
+  inline Result_std__vector_DownloadTask__ create_Result_std__vector_DownloadTask__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<DownloadTask>>::withError(error);
+  }
+  
+  // pragma MARK: Result<DownloadQueueStatus>
+  using Result_DownloadQueueStatus_ = Result<DownloadQueueStatus>;
+  inline Result_DownloadQueueStatus_ create_Result_DownloadQueueStatus_(const DownloadQueueStatus& value) noexcept {
+    return Result<DownloadQueueStatus>::withValue(value);
+  }
+  inline Result_DownloadQueueStatus_ create_Result_DownloadQueueStatus_(const std::exception_ptr& error) noexcept {
+    return Result<DownloadQueueStatus>::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<DownloadState>
+  using Result_DownloadState_ = Result<DownloadState>;
+  inline Result_DownloadState_ create_Result_DownloadState_(DownloadState value) noexcept {
+    return Result<DownloadState>::withValue(std::move(value));
+  }
+  inline Result_DownloadState_ create_Result_DownloadState_(const std::exception_ptr& error) noexcept {
+    return Result<DownloadState>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::variant<nitro::NullType, DownloadedTrack>>
+  using Result_std__variant_nitro__NullType__DownloadedTrack__ = Result<std::variant<nitro::NullType, DownloadedTrack>>;
+  inline Result_std__variant_nitro__NullType__DownloadedTrack__ create_Result_std__variant_nitro__NullType__DownloadedTrack__(const std::variant<nitro::NullType, DownloadedTrack>& value) noexcept {
+    return Result<std::variant<nitro::NullType, DownloadedTrack>>::withValue(value);
+  }
+  inline Result_std__variant_nitro__NullType__DownloadedTrack__ create_Result_std__variant_nitro__NullType__DownloadedTrack__(const std::exception_ptr& error) noexcept {
+    return Result<std::variant<nitro::NullType, DownloadedTrack>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::vector<DownloadedTrack>>
+  using Result_std__vector_DownloadedTrack__ = Result<std::vector<DownloadedTrack>>;
+  inline Result_std__vector_DownloadedTrack__ create_Result_std__vector_DownloadedTrack__(const std::vector<DownloadedTrack>& value) noexcept {
+    return Result<std::vector<DownloadedTrack>>::withValue(value);
+  }
+  inline Result_std__vector_DownloadedTrack__ create_Result_std__vector_DownloadedTrack__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<DownloadedTrack>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::variant<nitro::NullType, DownloadedPlaylist>>
+  using Result_std__variant_nitro__NullType__DownloadedPlaylist__ = Result<std::variant<nitro::NullType, DownloadedPlaylist>>;
+  inline Result_std__variant_nitro__NullType__DownloadedPlaylist__ create_Result_std__variant_nitro__NullType__DownloadedPlaylist__(const std::variant<nitro::NullType, DownloadedPlaylist>& value) noexcept {
+    return Result<std::variant<nitro::NullType, DownloadedPlaylist>>::withValue(value);
+  }
+  inline Result_std__variant_nitro__NullType__DownloadedPlaylist__ create_Result_std__variant_nitro__NullType__DownloadedPlaylist__(const std::exception_ptr& error) noexcept {
+    return Result<std::variant<nitro::NullType, DownloadedPlaylist>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::vector<DownloadedPlaylist>>
+  using Result_std__vector_DownloadedPlaylist__ = Result<std::vector<DownloadedPlaylist>>;
+  inline Result_std__vector_DownloadedPlaylist__ create_Result_std__vector_DownloadedPlaylist__(const std::vector<DownloadedPlaylist>& value) noexcept {
+    return Result<std::vector<DownloadedPlaylist>>::withValue(value);
+  }
+  inline Result_std__vector_DownloadedPlaylist__ create_Result_std__vector_DownloadedPlaylist__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<DownloadedPlaylist>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::variant<nitro::NullType, std::string>>
+  using Result_std__variant_nitro__NullType__std__string__ = Result<std::variant<nitro::NullType, std::string>>;
+  inline Result_std__variant_nitro__NullType__std__string__ create_Result_std__variant_nitro__NullType__std__string__(const std::variant<nitro::NullType, std::string>& value) noexcept {
+    return Result<std::variant<nitro::NullType, std::string>>::withValue(value);
+  }
+  inline Result_std__variant_nitro__NullType__std__string__ create_Result_std__variant_nitro__NullType__std__string__(const std::exception_ptr& error) noexcept {
+    return Result<std::variant<nitro::NullType, std::string>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<DownloadStorageInfo>>>
+  using Result_std__shared_ptr_Promise_DownloadStorageInfo___ = Result<std::shared_ptr<Promise<DownloadStorageInfo>>>;
+  inline Result_std__shared_ptr_Promise_DownloadStorageInfo___ create_Result_std__shared_ptr_Promise_DownloadStorageInfo___(const std::shared_ptr<Promise<DownloadStorageInfo>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<DownloadStorageInfo>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_DownloadStorageInfo___ create_Result_std__shared_ptr_Promise_DownloadStorageInfo___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<DownloadStorageInfo>>>::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<PlaybackSource>
+  using Result_PlaybackSource_ = Result<PlaybackSource>;
+  inline Result_PlaybackSource_ create_Result_PlaybackSource_(PlaybackSource value) noexcept {
+    return Result<PlaybackSource>::withValue(std::move(value));
+  }
+  inline Result_PlaybackSource_ create_Result_PlaybackSource_(const std::exception_ptr& error) noexcept {
+    return Result<PlaybackSource>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::string>
+  using Result_std__string_ = Result<std::string>;
+  inline Result_std__string_ create_Result_std__string_(const std::string& value) noexcept {
+    return Result<std::string>::withValue(value);
+  }
+  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
+    return Result<std::string>::withError(error);
+  }
+  
+  // pragma MARK: std::vector<EqualizerBand>
+  /**
+   * Specialized version of `std::vector<EqualizerBand>`.
    */
-  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);
+  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;
   }
-  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return optional.has_value();
+  
+  // 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;
   }
-  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return *optional;
+  
+  // 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::variant<nitro::NullType, std::string>
+  // pragma MARK: std::function<void(bool /* enabled */)>
   /**
-   * 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.
+   * Specialized version of `std::function<void(bool)>`.
    */
-  struct std__variant_nitro__NullType__std__string_ {
-    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);
+  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);
     }
-    inline std::string get_1() const noexcept {
-      return std::get<1>(variant);
+  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::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);
     }
-  };
-  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);
+  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));
   }
-  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::function<void(const std::optional<std::variant<nitro::NullType, std::string>>& /* presetName */)>
+  /**
+   * Specialized version of `std::function<void(const std::optional<std::variant<nitro::NullType, std::string>>&)>`.
+   */
+  using Func_void_std__optional_std__variant_nitro__NullType__std__string__ = std::function<void(const std::optional<std::variant<nitro::NullType, std::string>>& /* presetName */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::optional<std::variant<nitro::NullType, std::string>>& / * presetName * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__optional_std__variant_nitro__NullType__std__string___Wrapper final {
+  public:
+    explicit Func_void_std__optional_std__variant_nitro__NullType__std__string___Wrapper(std::function<void(const std::optional<std::variant<nitro::NullType, std::string>>& /* presetName */)>&& func): _function(std::make_unique<std::function<void(const std::optional<std::variant<nitro::NullType, std::string>>& /* presetName */)>>(std::move(func))) {}
+    inline void call(std::optional<std::variant<nitro::NullType, std::string>> presetName) const noexcept {
+      _function->operator()(presetName);
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::optional<std::variant<nitro::NullType, std::string>>& /* presetName */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__optional_std__variant_nitro__NullType__std__string__ create_Func_void_std__optional_std__variant_nitro__NullType__std__string__(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__optional_std__variant_nitro__NullType__std__string___Wrapper wrap_Func_void_std__optional_std__variant_nitro__NullType__std__string__(Func_void_std__optional_std__variant_nitro__NullType__std__string__ value) noexcept {
+    return Func_void_std__optional_std__variant_nitro__NullType__std__string___Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::optional<std::variant<nitro::NullType, std::string>>
+  // pragma MARK: std::shared_ptr<HybridEqualizerSpec>
   /**
-   * Specialized version of `std::optional<std::variant<nitro::NullType, std::string>>`.
+   * Specialized version of `std::shared_ptr<HybridEqualizerSpec>`.
    */
-  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);
+  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 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 Result_std__vector_EqualizerBand__ create_Result_std__vector_EqualizerBand__(const std::exception_ptr& error) noexcept {
+    return Result<std::vector<EqualizerBand>>::withError(error);
   }
-  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;
+  
+  // pragma MARK: Result<GainRange>
+  using Result_GainRange_ = Result<GainRange>;
+  inline Result_GainRange_ create_Result_GainRange_(const GainRange& value) noexcept {
+    return Result<GainRange>::withValue(value);
+  }
+  inline Result_GainRange_ create_Result_GainRange_(const std::exception_ptr& error) noexcept {
+    return Result<GainRange>::withError(error);
   }
   
-  // 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: 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: Result<EqualizerState>
+  using Result_EqualizerState_ = Result<EqualizerState>;
+  inline Result_EqualizerState_ create_Result_EqualizerState_(const EqualizerState& value) noexcept {
+    return Result<EqualizerState>::withValue(value);
+  }
+  inline Result_EqualizerState_ create_Result_EqualizerState_(const std::exception_ptr& error) noexcept {
+    return Result<EqualizerState>::withError(error);
   }
   
   // pragma MARK: std::variant<nitro::NullType, Playlist>
@@ -192,21 +1098,6 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
     return vector;
   }
   
-  // pragma MARK: std::optional<double>
-  /**
-   * Specialized version of `std::optional<double>`.
-   */
-  using std__optional_double_ = std::optional<double>;
-  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
-    return std::optional<double>(value);
-  }
-  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
-    return *optional;
-  }
-  
   // pragma MARK: std::optional<QueueOperation>
   /**
    * Specialized version of `std::optional<QueueOperation>`.
@@ -278,15 +1169,6 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
   using std__weak_ptr_HybridPlayerQueueSpec_ = std::weak_ptr<HybridPlayerQueueSpec>;
   inline std__weak_ptr_HybridPlayerQueueSpec_ weakify_std__shared_ptr_HybridPlayerQueueSpec_(const std::shared_ptr<HybridPlayerQueueSpec>& strong) noexcept { return strong; }
   
-  // pragma MARK: Result<std::string>
-  using Result_std__string_ = Result<std::string>;
-  inline Result_std__string_ create_Result_std__string_(const std::string& value) noexcept {
-    return Result<std::string>::withValue(value);
-  }
-  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
-    return Result<std::string>::withError(error);
-  }
-  
   // pragma MARK: Result<std::variant<nitro::NullType, Playlist>>
   using Result_std__variant_nitro__NullType__Playlist__ = Result<std::variant<nitro::NullType, Playlist>>;
   inline Result_std__variant_nitro__NullType__Playlist__ create_Result_std__variant_nitro__NullType__Playlist__(const std::variant<nitro::NullType, Playlist>& value) noexcept {
@@ -305,13 +1187,50 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
     return Result<std::vector<Playlist>>::withError(error);
   }
   
-  // pragma MARK: Result<std::variant<nitro::NullType, std::string>>
-  using Result_std__variant_nitro__NullType__std__string__ = Result<std::variant<nitro::NullType, std::string>>;
-  inline Result_std__variant_nitro__NullType__std__string__ create_Result_std__variant_nitro__NullType__std__string__(const std::variant<nitro::NullType, std::string>& value) noexcept {
-    return Result<std::variant<nitro::NullType, std::string>>::withValue(value);
+  // pragma MARK: std::shared_ptr<Promise<bool>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<bool>>`.
+   */
+  using std__shared_ptr_Promise_bool__ = std::shared_ptr<Promise<bool>>;
+  inline std::shared_ptr<Promise<bool>> create_std__shared_ptr_Promise_bool__() noexcept {
+    return Promise<bool>::create();
   }
-  inline Result_std__variant_nitro__NullType__std__string__ create_Result_std__variant_nitro__NullType__std__string__(const std::exception_ptr& error) noexcept {
-    return Result<std::variant<nitro::NullType, std::string>>::withError(error);
+  inline PromiseHolder<bool> wrap_std__shared_ptr_Promise_bool__(std::shared_ptr<Promise<bool>> promise) noexcept {
+    return PromiseHolder<bool>(std::move(promise));
+  }
+  
+  // 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::variant<nitro::NullType, TrackItem>
@@ -358,19 +1277,38 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
     return *optional;
   }
   
-  // pragma MARK: std::optional<bool>
+  // pragma MARK: std::shared_ptr<Promise<PlayerState>>
   /**
-   * Specialized version of `std::optional<bool>`.
+   * Specialized version of `std::shared_ptr<Promise<PlayerState>>`.
    */
-  using std__optional_bool_ = std::optional<bool>;
-  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
-    return std::optional<bool>(value);
+  using std__shared_ptr_Promise_PlayerState__ = std::shared_ptr<Promise<PlayerState>>;
+  inline std::shared_ptr<Promise<PlayerState>> create_std__shared_ptr_Promise_PlayerState__() noexcept {
+    return Promise<PlayerState>::create();
   }
-  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
-    return optional.has_value();
+  inline PromiseHolder<PlayerState> wrap_std__shared_ptr_Promise_PlayerState__(std::shared_ptr<Promise<PlayerState>> promise) noexcept {
+    return PromiseHolder<PlayerState>(std::move(promise));
   }
-  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
-    return *optional;
+  
+  // pragma MARK: std::function<void(const PlayerState& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const PlayerState&)>`.
+   */
+  using Func_void_PlayerState = std::function<void(const PlayerState& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const PlayerState& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_PlayerState_Wrapper final {
+  public:
+    explicit Func_void_PlayerState_Wrapper(std::function<void(const PlayerState& /* result */)>&& func): _function(std::make_unique<std::function<void(const PlayerState& /* result */)>>(std::move(func))) {}
+    inline void call(PlayerState result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const PlayerState& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_PlayerState create_Func_void_PlayerState(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_PlayerState_Wrapper wrap_Func_void_PlayerState(Func_void_PlayerState value) noexcept {
+    return Func_void_PlayerState_Wrapper(std::move(value));
   }
   
   // pragma MARK: std::optional<Reason>
@@ -476,28 +1414,6 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
     return Func_void_double_double_std__optional_bool__Wrapper(std::move(value));
   }
   
-  // pragma MARK: std::function<void(bool /* connected */)>
-  /**
-   * Specialized version of `std::function<void(bool)>`.
-   */
-  using Func_void_bool = std::function<void(bool /* connected */)>;
-  /**
-   * Wrapper class for a `std::function<void(bool / * connected * /)>`, this can be used from Swift.
-   */
-  class Func_void_bool_Wrapper final {
-  public:
-    explicit Func_void_bool_Wrapper(std::function<void(bool /* connected */)>&& func): _function(std::make_unique<std::function<void(bool /* connected */)>>(std::move(func))) {}
-    inline void call(bool connected) const noexcept {
-      _function->operator()(connected);
-    }
-  private:
-    std::unique_ptr<std::function<void(bool /* connected */)>> _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<HybridTrackPlayerSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridTrackPlayerSpec>`.
@@ -510,22 +1426,31 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
   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<PlayerState>
-  using Result_PlayerState_ = Result<PlayerState>;
-  inline Result_PlayerState_ create_Result_PlayerState_(const PlayerState& value) noexcept {
-    return Result<PlayerState>::withValue(value);
+  // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
+  using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::withValue(value);
   }
-  inline Result_PlayerState_ create_Result_PlayerState_(const std::exception_ptr& error) noexcept {
-    return Result<PlayerState>::withError(error);
+  inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<bool>>>::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));
+  // pragma MARK: Result<std::shared_ptr<Promise<std::vector<TrackItem>>>>
+  using Result_std__shared_ptr_Promise_std__vector_TrackItem____ = Result<std::shared_ptr<Promise<std::vector<TrackItem>>>>;
+  inline Result_std__shared_ptr_Promise_std__vector_TrackItem____ create_Result_std__shared_ptr_Promise_std__vector_TrackItem____(const std::shared_ptr<Promise<std::vector<TrackItem>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<TrackItem>>>>::withValue(value);
   }
-  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
-    return Result<bool>::withError(error);
+  inline Result_std__shared_ptr_Promise_std__vector_TrackItem____ create_Result_std__shared_ptr_Promise_std__vector_TrackItem____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::vector<TrackItem>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<PlayerState>>>
+  using Result_std__shared_ptr_Promise_PlayerState___ = Result<std::shared_ptr<Promise<PlayerState>>>;
+  inline Result_std__shared_ptr_Promise_PlayerState___ create_Result_std__shared_ptr_Promise_PlayerState___(const std::shared_ptr<Promise<PlayerState>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<PlayerState>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_PlayerState___ create_Result_std__shared_ptr_Promise_PlayerState___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<PlayerState>>>::withError(error);
   }
 
 } // namespace margelo::nitro::nitroplayer::bridge::swift