spactureai-mobile-player 1.0.30

package/nitrogen/generated/ios/UnifiedPlayer-Swift-Cxx-Umbrella.hpp

@@ -0,0 +1,162 @@
+///
+/// UnifiedPlayer-Swift-Cxx-Umbrella.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 `BandwidthData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct BandwidthData; }
+// Forward declaration of `BufferConfig` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct BufferConfig; }
+// Forward declaration of `CustomVideoMetadata` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct CustomVideoMetadata; }
+// Forward declaration of `HybridVideoPlayerEventEmitterSpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoPlayerEventEmitterSpec; }
+// Forward declaration of `HybridVideoPlayerFactorySpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoPlayerFactorySpec; }
+// Forward declaration of `HybridVideoPlayerSourceFactorySpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoPlayerSourceFactorySpec; }
+// Forward declaration of `HybridVideoPlayerSourceSpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoPlayerSourceSpec; }
+// Forward declaration of `HybridVideoPlayerSpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoPlayerSpec; }
+// Forward declaration of `HybridVideoViewViewManagerFactorySpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoViewViewManagerFactorySpec; }
+// Forward declaration of `HybridVideoViewViewManagerSpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoViewViewManagerSpec; }
+// Forward declaration of `IgnoreSilentSwitchMode` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class IgnoreSilentSwitchMode; }
+// Forward declaration of `ListenerSubscription` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct ListenerSubscription; }
+// Forward declaration of `LivePlaybackParams` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct LivePlaybackParams; }
+// Forward declaration of `MixAudioMode` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class MixAudioMode; }
+// Forward declaration of `NativeDrmParams` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct NativeDrmParams; }
+// Forward declaration of `NativeExternalSubtitle` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct NativeExternalSubtitle; }
+// Forward declaration of `NativeVideoConfig` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct NativeVideoConfig; }
+// Forward declaration of `OnGetLicensePayload` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct OnGetLicensePayload; }
+// Forward declaration of `ResizeMode` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class ResizeMode; }
+// Forward declaration of `Resolution` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct Resolution; }
+// Forward declaration of `SourceType` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class SourceType; }
+// Forward declaration of `SubtitleType` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class SubtitleType; }
+// Forward declaration of `SurfaceType` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class SurfaceType; }
+// Forward declaration of `TextTrack` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct TextTrack; }
+// Forward declaration of `TimedMetadataObject` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct TimedMetadataObject; }
+// Forward declaration of `TimedMetadata` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct TimedMetadata; }
+// Forward declaration of `VideoInformation` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct VideoInformation; }
+// Forward declaration of `VideoOrientation` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class VideoOrientation; }
+// Forward declaration of `VideoPlayerStatus` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class VideoPlayerStatus; }
+// Forward declaration of `onLoadData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct onLoadData; }
+// Forward declaration of `onLoadStartData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct onLoadStartData; }
+// Forward declaration of `onPlaybackStateChangeData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct onPlaybackStateChangeData; }
+// Forward declaration of `onProgressData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct onProgressData; }
+// Forward declaration of `onVolumeChangeData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct onVolumeChangeData; }
+
+// Include C++ defined types
+#include "BandwidthData.hpp"
+#include "BufferConfig.hpp"
+#include "CustomVideoMetadata.hpp"
+#include "HybridVideoPlayerEventEmitterSpec.hpp"
+#include "HybridVideoPlayerFactorySpec.hpp"
+#include "HybridVideoPlayerSourceFactorySpec.hpp"
+#include "HybridVideoPlayerSourceSpec.hpp"
+#include "HybridVideoPlayerSpec.hpp"
+#include "HybridVideoViewViewManagerFactorySpec.hpp"
+#include "HybridVideoViewViewManagerSpec.hpp"
+#include "IgnoreSilentSwitchMode.hpp"
+#include "ListenerSubscription.hpp"
+#include "LivePlaybackParams.hpp"
+#include "MixAudioMode.hpp"
+#include "NativeDrmParams.hpp"
+#include "NativeExternalSubtitle.hpp"
+#include "NativeVideoConfig.hpp"
+#include "OnGetLicensePayload.hpp"
+#include "ResizeMode.hpp"
+#include "Resolution.hpp"
+#include "SourceType.hpp"
+#include "SubtitleType.hpp"
+#include "SurfaceType.hpp"
+#include "TextTrack.hpp"
+#include "TimedMetadata.hpp"
+#include "TimedMetadataObject.hpp"
+#include "VideoInformation.hpp"
+#include "VideoOrientation.hpp"
+#include "VideoPlayerStatus.hpp"
+#include "onLoadData.hpp"
+#include "onLoadStartData.hpp"
+#include "onPlaybackStateChangeData.hpp"
+#include "onProgressData.hpp"
+#include "onVolumeChangeData.hpp"
+#include <NitroModules/Null.hpp>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/Result.hpp>
+#include <exception>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <variant>
+#include <vector>
+
+// C++ helpers for Swift
+#include "UnifiedPlayer-Swift-Cxx-Bridge.hpp"
+
+// Common C++ types used in Swift
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
+#include <NitroModules/RuntimeError.hpp>
+#include <NitroModules/DateToChronoDate.hpp>
+
+// Forward declarations of Swift defined types
+// Forward declaration of `HybridVideoPlayerEventEmitterSpec_cxx` to properly resolve imports.
+namespace UnifiedPlayer { class HybridVideoPlayerEventEmitterSpec_cxx; }
+// Forward declaration of `HybridVideoPlayerFactorySpec_cxx` to properly resolve imports.
+namespace UnifiedPlayer { class HybridVideoPlayerFactorySpec_cxx; }
+// Forward declaration of `HybridVideoPlayerSourceFactorySpec_cxx` to properly resolve imports.
+namespace UnifiedPlayer { class HybridVideoPlayerSourceFactorySpec_cxx; }
+// Forward declaration of `HybridVideoPlayerSourceSpec_cxx` to properly resolve imports.
+namespace UnifiedPlayer { class HybridVideoPlayerSourceSpec_cxx; }
+// Forward declaration of `HybridVideoPlayerSpec_cxx` to properly resolve imports.
+namespace UnifiedPlayer { class HybridVideoPlayerSpec_cxx; }
+// Forward declaration of `HybridVideoViewViewManagerFactorySpec_cxx` to properly resolve imports.
+namespace UnifiedPlayer { class HybridVideoViewViewManagerFactorySpec_cxx; }
+// Forward declaration of `HybridVideoViewViewManagerSpec_cxx` to properly resolve imports.
+namespace UnifiedPlayer { class HybridVideoViewViewManagerSpec_cxx; }
+
+// Include Swift defined types
+#if __has_include("UnifiedPlayer-Swift.h")
+// This header is generated by Xcode/Swift on every app build.
+// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "UnifiedPlayer".
+#include "UnifiedPlayer-Swift.h"
+// Same as above, but used when building with frameworks (`use_frameworks`)
+#elif __has_include(<UnifiedPlayer/UnifiedPlayer-Swift.h>)
+#include <UnifiedPlayer/UnifiedPlayer-Swift.h>
+#else
+#error UnifiedPlayer's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "UnifiedPlayer", and try building the app first.
+#endif

package/nitrogen/generated/ios/UnifiedPlayerAutolinking.mm

@@ -0,0 +1,49 @@
+///
+/// UnifiedPlayerAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+#import "UnifiedPlayer-Swift-Cxx-Umbrella.hpp"
+#import <type_traits>
+
+#include "HybridVideoPlayerFactorySpecSwift.hpp"
+#include "HybridVideoPlayerSourceFactorySpecSwift.hpp"
+#include "HybridVideoViewViewManagerFactorySpecSwift.hpp"
+
+@interface UnifiedPlayerAutolinking : NSObject
+@end
+
+@implementation UnifiedPlayerAutolinking
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::unifiedplayer;
+
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "VideoPlayerFactory",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridVideoPlayerFactorySpec> hybridObject = UnifiedPlayer::UnifiedPlayerAutolinking::createVideoPlayerFactory();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "VideoPlayerSourceFactory",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridVideoPlayerSourceFactorySpec> hybridObject = UnifiedPlayer::UnifiedPlayerAutolinking::createVideoPlayerSourceFactory();
+      return hybridObject;
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "VideoViewViewManagerFactory",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridVideoViewViewManagerFactorySpec> hybridObject = UnifiedPlayer::UnifiedPlayerAutolinking::createVideoViewViewManagerFactory();
+      return hybridObject;
+    }
+  );
+}
+
+@end

package/nitrogen/generated/ios/UnifiedPlayerAutolinking.swift

@@ -0,0 +1,50 @@
+///
+/// UnifiedPlayerAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+// TODO: Use empty enums once Swift supports exporting them as namespaces
+//       See: https://github.com/swiftlang/swift/pull/83616
+public final class UnifiedPlayerAutolinking {
+  public typealias bridge = margelo.nitro.unifiedplayer.bridge.swift
+
+  public static func createVideoPlayerFactory() -> bridge.std__shared_ptr_HybridVideoPlayerFactorySpec_ {
+    let hybridObject = HybridVideoPlayerFactory()
+    return { () -> bridge.std__shared_ptr_HybridVideoPlayerFactorySpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  public static func isVideoPlayerFactoryRecyclable() -> Bool {
+    return HybridVideoPlayerFactory.self is any RecyclableView.Type
+  }
+  
+  public static func createVideoPlayerSourceFactory() -> bridge.std__shared_ptr_HybridVideoPlayerSourceFactorySpec_ {
+    let hybridObject = HybridVideoPlayerSourceFactory()
+    return { () -> bridge.std__shared_ptr_HybridVideoPlayerSourceFactorySpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  public static func isVideoPlayerSourceFactoryRecyclable() -> Bool {
+    return HybridVideoPlayerSourceFactory.self is any RecyclableView.Type
+  }
+  
+  public static func createVideoViewViewManagerFactory() -> bridge.std__shared_ptr_HybridVideoViewViewManagerFactorySpec_ {
+    let hybridObject = HybridVideoViewViewManagerFactory()
+    return { () -> bridge.std__shared_ptr_HybridVideoViewViewManagerFactorySpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  public static func isVideoViewViewManagerFactoryRecyclable() -> Bool {
+    return HybridVideoViewViewManagerFactory.self is any RecyclableView.Type
+  }
+}

package/nitrogen/generated/ios/c++/HybridVideoPlayerEventEmitterSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridVideoPlayerEventEmitterSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridVideoPlayerEventEmitterSpecSwift.hpp"
+
+namespace margelo::nitro::unifiedplayer {
+} // namespace margelo::nitro::unifiedplayer

package/nitrogen/generated/ios/c++/HybridVideoPlayerEventEmitterSpecSwift.hpp

@@ -0,0 +1,279 @@
+///
+/// HybridVideoPlayerEventEmitterSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridVideoPlayerEventEmitterSpec.hpp"
+
+// Forward declaration of `HybridVideoPlayerEventEmitterSpec_cxx` to properly resolve imports.
+namespace UnifiedPlayer { class HybridVideoPlayerEventEmitterSpec_cxx; }
+
+// Forward declaration of `ListenerSubscription` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct ListenerSubscription; }
+// Forward declaration of `BandwidthData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct BandwidthData; }
+// Forward declaration of `onLoadData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct onLoadData; }
+// Forward declaration of `VideoOrientation` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class VideoOrientation; }
+// Forward declaration of `onLoadStartData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct onLoadStartData; }
+// Forward declaration of `SourceType` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class SourceType; }
+// Forward declaration of `HybridVideoPlayerSourceSpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoPlayerSourceSpec; }
+// Forward declaration of `onPlaybackStateChangeData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct onPlaybackStateChangeData; }
+// Forward declaration of `onProgressData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct onProgressData; }
+// Forward declaration of `VideoPlayerStatus` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { enum class VideoPlayerStatus; }
+// Forward declaration of `TimedMetadata` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct TimedMetadata; }
+// Forward declaration of `TimedMetadataObject` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct TimedMetadataObject; }
+// Forward declaration of `TextTrack` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct TextTrack; }
+// Forward declaration of `onVolumeChangeData` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { struct onVolumeChangeData; }
+
+#include "ListenerSubscription.hpp"
+#include <functional>
+#include "BandwidthData.hpp"
+#include <optional>
+#include "onLoadData.hpp"
+#include "VideoOrientation.hpp"
+#include "onLoadStartData.hpp"
+#include "SourceType.hpp"
+#include <memory>
+#include "HybridVideoPlayerSourceSpec.hpp"
+#include "onPlaybackStateChangeData.hpp"
+#include "onProgressData.hpp"
+#include "VideoPlayerStatus.hpp"
+#include "TimedMetadata.hpp"
+#include "TimedMetadataObject.hpp"
+#include <vector>
+#include <string>
+#include <NitroModules/Null.hpp>
+#include "TextTrack.hpp"
+#include <variant>
+#include "onVolumeChangeData.hpp"
+
+#include "UnifiedPlayer-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::unifiedplayer {
+
+  /**
+   * The C++ part of HybridVideoPlayerEventEmitterSpec_cxx.swift.
+   *
+   * HybridVideoPlayerEventEmitterSpecSwift (C++) accesses HybridVideoPlayerEventEmitterSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridVideoPlayerEventEmitterSpec_cxx can directly inherit from the C++ class HybridVideoPlayerEventEmitterSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridVideoPlayerEventEmitterSpecSwift: public virtual HybridVideoPlayerEventEmitterSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridVideoPlayerEventEmitterSpecSwift(const UnifiedPlayer::HybridVideoPlayerEventEmitterSpec_cxx& swiftPart):
+      HybridObject(HybridVideoPlayerEventEmitterSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline UnifiedPlayer::HybridVideoPlayerEventEmitterSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridVideoPlayerEventEmitterSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline ListenerSubscription addOnAudioBecomingNoisyListener(const std::function<void()>& listener) override {
+      auto __result = _swiftPart.addOnAudioBecomingNoisyListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnAudioFocusChangeListener(const std::function<void(bool /* hasAudioFocus */)>& listener) override {
+      auto __result = _swiftPart.addOnAudioFocusChangeListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnBandwidthUpdateListener(const std::function<void(const BandwidthData& /* data */)>& listener) override {
+      auto __result = _swiftPart.addOnBandwidthUpdateListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnBufferListener(const std::function<void(bool /* buffering */)>& listener) override {
+      auto __result = _swiftPart.addOnBufferListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnControlsVisibleChangeListener(const std::function<void(bool /* visible */)>& listener) override {
+      auto __result = _swiftPart.addOnControlsVisibleChangeListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnEndListener(const std::function<void()>& listener) override {
+      auto __result = _swiftPart.addOnEndListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnExternalPlaybackChangeListener(const std::function<void(bool /* externalPlaybackActive */)>& listener) override {
+      auto __result = _swiftPart.addOnExternalPlaybackChangeListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnLoadListener(const std::function<void(const onLoadData& /* data */)>& listener) override {
+      auto __result = _swiftPart.addOnLoadListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnLoadStartListener(const std::function<void(const onLoadStartData& /* data */)>& listener) override {
+      auto __result = _swiftPart.addOnLoadStartListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnPlaybackStateChangeListener(const std::function<void(const onPlaybackStateChangeData& /* data */)>& listener) override {
+      auto __result = _swiftPart.addOnPlaybackStateChangeListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnPlaybackRateChangeListener(const std::function<void(double /* rate */)>& listener) override {
+      auto __result = _swiftPart.addOnPlaybackRateChangeListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnProgressListener(const std::function<void(const onProgressData& /* data */)>& listener) override {
+      auto __result = _swiftPart.addOnProgressListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnReadyToDisplayListener(const std::function<void()>& listener) override {
+      auto __result = _swiftPart.addOnReadyToDisplayListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnSeekListener(const std::function<void(double /* position */)>& listener) override {
+      auto __result = _swiftPart.addOnSeekListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnStatusChangeListener(const std::function<void(VideoPlayerStatus /* status */)>& listener) override {
+      auto __result = _swiftPart.addOnStatusChangeListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnTimedMetadataListener(const std::function<void(const TimedMetadata& /* data */)>& listener) override {
+      auto __result = _swiftPart.addOnTimedMetadataListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnTextTrackDataChangedListener(const std::function<void(const std::vector<std::string>& /* data */)>& listener) override {
+      auto __result = _swiftPart.addOnTextTrackDataChangedListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnTrackChangeListener(const std::function<void(const std::optional<std::variant<nitro::NullType, TextTrack>>& /* track */)>& listener) override {
+      auto __result = _swiftPart.addOnTrackChangeListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline ListenerSubscription addOnVolumeChangeListener(const std::function<void(const onVolumeChangeData& /* data */)>& listener) override {
+      auto __result = _swiftPart.addOnVolumeChangeListener(listener);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void clearAllListeners() override {
+      auto __result = _swiftPart.clearAllListeners();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    UnifiedPlayer::HybridVideoPlayerEventEmitterSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::unifiedplayer

package/nitrogen/generated/ios/c++/HybridVideoPlayerFactorySpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridVideoPlayerFactorySpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridVideoPlayerFactorySpecSwift.hpp"
+
+namespace margelo::nitro::unifiedplayer {
+} // namespace margelo::nitro::unifiedplayer

package/nitrogen/generated/ios/c++/HybridVideoPlayerFactorySpecSwift.hpp

@@ -0,0 +1,87 @@
+///
+/// HybridVideoPlayerFactorySpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridVideoPlayerFactorySpec.hpp"
+
+// Forward declaration of `HybridVideoPlayerFactorySpec_cxx` to properly resolve imports.
+namespace UnifiedPlayer { class HybridVideoPlayerFactorySpec_cxx; }
+
+// Forward declaration of `HybridVideoPlayerSpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoPlayerSpec; }
+// Forward declaration of `HybridVideoPlayerSourceSpec` to properly resolve imports.
+namespace margelo::nitro::unifiedplayer { class HybridVideoPlayerSourceSpec; }
+
+#include <memory>
+#include "HybridVideoPlayerSpec.hpp"
+#include "HybridVideoPlayerSourceSpec.hpp"
+
+#include "UnifiedPlayer-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::unifiedplayer {
+
+  /**
+   * The C++ part of HybridVideoPlayerFactorySpec_cxx.swift.
+   *
+   * HybridVideoPlayerFactorySpecSwift (C++) accesses HybridVideoPlayerFactorySpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridVideoPlayerFactorySpec_cxx can directly inherit from the C++ class HybridVideoPlayerFactorySpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridVideoPlayerFactorySpecSwift: public virtual HybridVideoPlayerFactorySpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridVideoPlayerFactorySpecSwift(const UnifiedPlayer::HybridVideoPlayerFactorySpec_cxx& swiftPart):
+      HybridObject(HybridVideoPlayerFactorySpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline UnifiedPlayer::HybridVideoPlayerFactorySpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridVideoPlayerFactorySpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<HybridVideoPlayerSpec> createPlayer(const std::shared_ptr<HybridVideoPlayerSourceSpec>& source) override {
+      auto __result = _swiftPart.createPlayer(source);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    UnifiedPlayer::HybridVideoPlayerFactorySpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::unifiedplayer

package/nitrogen/generated/ios/c++/HybridVideoPlayerSourceFactorySpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridVideoPlayerSourceFactorySpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridVideoPlayerSourceFactorySpecSwift.hpp"
+
+namespace margelo::nitro::unifiedplayer {
+} // namespace margelo::nitro::unifiedplayer