@pigeonmal/react-native-video 7.0.0-beta.10

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

@@ -0,0 +1,125 @@
+///
+/// HybridVideoPlayerSourceFactorySpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridVideoPlayerSourceFactorySpec.hpp"
+
+// Forward declaration of `HybridVideoPlayerSourceFactorySpec_cxx` to properly resolve imports.
+namespace ReactNativeVideo { class HybridVideoPlayerSourceFactorySpec_cxx; }
+
+// Forward declaration of `HybridVideoPlayerSourceSpec` to properly resolve imports.
+namespace margelo::nitro::video { class HybridVideoPlayerSourceSpec; }
+// Forward declaration of `NativeVideoConfig` to properly resolve imports.
+namespace margelo::nitro::video { struct NativeVideoConfig; }
+// Forward declaration of `NativeExternalSubtitle` to properly resolve imports.
+namespace margelo::nitro::video { struct NativeExternalSubtitle; }
+// Forward declaration of `SubtitleType` to properly resolve imports.
+namespace margelo::nitro::video { enum class SubtitleType; }
+// Forward declaration of `NativeDrmParams` to properly resolve imports.
+namespace margelo::nitro::video { struct NativeDrmParams; }
+// Forward declaration of `OnGetLicensePayload` to properly resolve imports.
+namespace margelo::nitro::video { struct OnGetLicensePayload; }
+// Forward declaration of `BufferConfig` to properly resolve imports.
+namespace margelo::nitro::video { struct BufferConfig; }
+// Forward declaration of `LivePlaybackParams` to properly resolve imports.
+namespace margelo::nitro::video { struct LivePlaybackParams; }
+// Forward declaration of `Resolution` to properly resolve imports.
+namespace margelo::nitro::video { struct Resolution; }
+// Forward declaration of `CustomVideoMetadata` to properly resolve imports.
+namespace margelo::nitro::video { struct CustomVideoMetadata; }
+// Forward declaration of `ExternalAudio` to properly resolve imports.
+namespace margelo::nitro::video { struct ExternalAudio; }
+// Forward declaration of `ExternalForcedType` to properly resolve imports.
+namespace margelo::nitro::video { enum class ExternalForcedType; }
+
+#include <memory>
+#include "HybridVideoPlayerSourceSpec.hpp"
+#include <string>
+#include "NativeVideoConfig.hpp"
+#include "NativeExternalSubtitle.hpp"
+#include <vector>
+#include <optional>
+#include "SubtitleType.hpp"
+#include "NativeDrmParams.hpp"
+#include <unordered_map>
+#include <NitroModules/Promise.hpp>
+#include "OnGetLicensePayload.hpp"
+#include <functional>
+#include "BufferConfig.hpp"
+#include "LivePlaybackParams.hpp"
+#include "Resolution.hpp"
+#include "CustomVideoMetadata.hpp"
+#include "ExternalAudio.hpp"
+#include "ExternalForcedType.hpp"
+
+#include "ReactNativeVideo-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::video {
+
+  /**
+   * The C++ part of HybridVideoPlayerSourceFactorySpec_cxx.swift.
+   *
+   * HybridVideoPlayerSourceFactorySpecSwift (C++) accesses HybridVideoPlayerSourceFactorySpec_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, HybridVideoPlayerSourceFactorySpec_cxx can directly inherit from the C++ class HybridVideoPlayerSourceFactorySpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridVideoPlayerSourceFactorySpecSwift: public virtual HybridVideoPlayerSourceFactorySpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridVideoPlayerSourceFactorySpecSwift(const ReactNativeVideo::HybridVideoPlayerSourceFactorySpec_cxx& swiftPart):
+      HybridObject(HybridVideoPlayerSourceFactorySpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline ReactNativeVideo::HybridVideoPlayerSourceFactorySpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<HybridVideoPlayerSourceSpec> fromUri(const std::string& uri) override {
+      auto __result = _swiftPart.fromUri(uri);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<HybridVideoPlayerSourceSpec> fromVideoConfig(const NativeVideoConfig& config) override {
+      auto __result = _swiftPart.fromVideoConfig(std::forward<decltype(config)>(config));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    ReactNativeVideo::HybridVideoPlayerSourceFactorySpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::video

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

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

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

@@ -0,0 +1,125 @@
+///
+/// HybridVideoPlayerSourceSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridVideoPlayerSourceSpec.hpp"
+
+// Forward declaration of `HybridVideoPlayerSourceSpec_cxx` to properly resolve imports.
+namespace ReactNativeVideo { class HybridVideoPlayerSourceSpec_cxx; }
+
+// Forward declaration of `NativeVideoConfig` to properly resolve imports.
+namespace margelo::nitro::video { struct NativeVideoConfig; }
+// Forward declaration of `NativeExternalSubtitle` to properly resolve imports.
+namespace margelo::nitro::video { struct NativeExternalSubtitle; }
+// Forward declaration of `SubtitleType` to properly resolve imports.
+namespace margelo::nitro::video { enum class SubtitleType; }
+// Forward declaration of `NativeDrmParams` to properly resolve imports.
+namespace margelo::nitro::video { struct NativeDrmParams; }
+// Forward declaration of `OnGetLicensePayload` to properly resolve imports.
+namespace margelo::nitro::video { struct OnGetLicensePayload; }
+// Forward declaration of `BufferConfig` to properly resolve imports.
+namespace margelo::nitro::video { struct BufferConfig; }
+// Forward declaration of `LivePlaybackParams` to properly resolve imports.
+namespace margelo::nitro::video { struct LivePlaybackParams; }
+// Forward declaration of `Resolution` to properly resolve imports.
+namespace margelo::nitro::video { struct Resolution; }
+// Forward declaration of `CustomVideoMetadata` to properly resolve imports.
+namespace margelo::nitro::video { struct CustomVideoMetadata; }
+// Forward declaration of `ExternalAudio` to properly resolve imports.
+namespace margelo::nitro::video { struct ExternalAudio; }
+// Forward declaration of `ExternalForcedType` to properly resolve imports.
+namespace margelo::nitro::video { enum class ExternalForcedType; }
+// Forward declaration of `VideoInformation` to properly resolve imports.
+namespace margelo::nitro::video { struct VideoInformation; }
+// Forward declaration of `VideoOrientation` to properly resolve imports.
+namespace margelo::nitro::video { enum class VideoOrientation; }
+
+#include <string>
+#include "NativeVideoConfig.hpp"
+#include "NativeExternalSubtitle.hpp"
+#include <vector>
+#include <optional>
+#include "SubtitleType.hpp"
+#include "NativeDrmParams.hpp"
+#include <unordered_map>
+#include <NitroModules/Promise.hpp>
+#include "OnGetLicensePayload.hpp"
+#include <functional>
+#include "BufferConfig.hpp"
+#include "LivePlaybackParams.hpp"
+#include "Resolution.hpp"
+#include "CustomVideoMetadata.hpp"
+#include "ExternalAudio.hpp"
+#include "ExternalForcedType.hpp"
+#include "VideoInformation.hpp"
+#include "VideoOrientation.hpp"
+
+#include "ReactNativeVideo-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::video {
+
+  /**
+   * The C++ part of HybridVideoPlayerSourceSpec_cxx.swift.
+   *
+   * HybridVideoPlayerSourceSpecSwift (C++) accesses HybridVideoPlayerSourceSpec_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, HybridVideoPlayerSourceSpec_cxx can directly inherit from the C++ class HybridVideoPlayerSourceSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridVideoPlayerSourceSpecSwift: public virtual HybridVideoPlayerSourceSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridVideoPlayerSourceSpecSwift(const ReactNativeVideo::HybridVideoPlayerSourceSpec_cxx& swiftPart):
+      HybridObject(HybridVideoPlayerSourceSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline ReactNativeVideo::HybridVideoPlayerSourceSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline std::string getUri() noexcept override {
+      auto __result = _swiftPart.getUri();
+      return __result;
+    }
+    inline NativeVideoConfig getConfig() noexcept override {
+      return _swiftPart.getConfig();
+    }
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<VideoInformation>> getAssetInformationAsync() override {
+      auto __result = _swiftPart.getAssetInformationAsync();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    ReactNativeVideo::HybridVideoPlayerSourceSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::video

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

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

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

@@ -0,0 +1,283 @@
+///
+/// HybridVideoPlayerSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridVideoPlayerSpec.hpp"
+
+// Forward declaration of `HybridVideoPlayerSpec_cxx` to properly resolve imports.
+namespace ReactNativeVideo { class HybridVideoPlayerSpec_cxx; }
+
+// Forward declaration of `HybridVideoPlayerSourceSpec` to properly resolve imports.
+namespace margelo::nitro::video { class HybridVideoPlayerSourceSpec; }
+// Forward declaration of `HybridVideoPlayerEventEmitterSpec` to properly resolve imports.
+namespace margelo::nitro::video { class HybridVideoPlayerEventEmitterSpec; }
+// Forward declaration of `VideoPlayerStatus` to properly resolve imports.
+namespace margelo::nitro::video { enum class VideoPlayerStatus; }
+// Forward declaration of `MixAudioMode` to properly resolve imports.
+namespace margelo::nitro::video { enum class MixAudioMode; }
+// Forward declaration of `IgnoreSilentSwitchMode` to properly resolve imports.
+namespace margelo::nitro::video { enum class IgnoreSilentSwitchMode; }
+// Forward declaration of `PlayerTrack` to properly resolve imports.
+namespace margelo::nitro::video { struct PlayerTrack; }
+// Forward declaration of `AllPlayerTracks` to properly resolve imports.
+namespace margelo::nitro::video { struct AllPlayerTracks; }
+// Forward declaration of `VideoPlayerTrack` to properly resolve imports.
+namespace margelo::nitro::video { struct VideoPlayerTrack; }
+// Forward declaration of `TrackType` to properly resolve imports.
+namespace margelo::nitro::video { enum class TrackType; }
+
+#include <memory>
+#include "HybridVideoPlayerSourceSpec.hpp"
+#include "HybridVideoPlayerEventEmitterSpec.hpp"
+#include "VideoPlayerStatus.hpp"
+#include "MixAudioMode.hpp"
+#include "IgnoreSilentSwitchMode.hpp"
+#include "PlayerTrack.hpp"
+#include <optional>
+#include <string>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <vector>
+#include "AllPlayerTracks.hpp"
+#include "VideoPlayerTrack.hpp"
+#include "TrackType.hpp"
+
+#include "ReactNativeVideo-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::video {
+
+  /**
+   * The C++ part of HybridVideoPlayerSpec_cxx.swift.
+   *
+   * HybridVideoPlayerSpecSwift (C++) accesses HybridVideoPlayerSpec_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, HybridVideoPlayerSpec_cxx can directly inherit from the C++ class HybridVideoPlayerSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridVideoPlayerSpecSwift: public virtual HybridVideoPlayerSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridVideoPlayerSpecSwift(const ReactNativeVideo::HybridVideoPlayerSpec_cxx& swiftPart):
+      HybridObject(HybridVideoPlayerSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline ReactNativeVideo::HybridVideoPlayerSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    inline std::shared_ptr<HybridVideoPlayerSourceSpec> getSource() noexcept override {
+      auto __result = _swiftPart.getSource();
+      return __result;
+    }
+    inline std::shared_ptr<HybridVideoPlayerEventEmitterSpec> getEventEmitter() noexcept override {
+      auto __result = _swiftPart.getEventEmitter();
+      return __result;
+    }
+    inline bool getShowNotificationControls() noexcept override {
+      return _swiftPart.getShowNotificationControls();
+    }
+    inline void setShowNotificationControls(bool showNotificationControls) noexcept override {
+      _swiftPart.setShowNotificationControls(std::forward<decltype(showNotificationControls)>(showNotificationControls));
+    }
+    inline VideoPlayerStatus getStatus() noexcept override {
+      auto __result = _swiftPart.getStatus();
+      return static_cast<VideoPlayerStatus>(__result);
+    }
+    inline double getDuration() noexcept override {
+      return _swiftPart.getDuration();
+    }
+    inline double getVolume() noexcept override {
+      return _swiftPart.getVolume();
+    }
+    inline void setVolume(double volume) noexcept override {
+      _swiftPart.setVolume(std::forward<decltype(volume)>(volume));
+    }
+    inline double getCurrentTime() noexcept override {
+      return _swiftPart.getCurrentTime();
+    }
+    inline void setCurrentTime(double currentTime) noexcept override {
+      _swiftPart.setCurrentTime(std::forward<decltype(currentTime)>(currentTime));
+    }
+    inline double getProgressEventInterval() noexcept override {
+      return _swiftPart.getProgressEventInterval();
+    }
+    inline void setProgressEventInterval(double progressEventInterval) noexcept override {
+      _swiftPart.setProgressEventInterval(std::forward<decltype(progressEventInterval)>(progressEventInterval));
+    }
+    inline int64_t getSubtitleDelay() noexcept override {
+      return _swiftPart.getSubtitleDelay();
+    }
+    inline void setSubtitleDelay(int64_t subtitleDelay) noexcept override {
+      _swiftPart.setSubtitleDelay(std::forward<decltype(subtitleDelay)>(subtitleDelay));
+    }
+    inline bool getMuted() noexcept override {
+      return _swiftPart.getMuted();
+    }
+    inline void setMuted(bool muted) noexcept override {
+      _swiftPart.setMuted(std::forward<decltype(muted)>(muted));
+    }
+    inline bool getLoop() noexcept override {
+      return _swiftPart.getLoop();
+    }
+    inline void setLoop(bool loop) noexcept override {
+      _swiftPart.setLoop(std::forward<decltype(loop)>(loop));
+    }
+    inline double getRate() noexcept override {
+      return _swiftPart.getRate();
+    }
+    inline void setRate(double rate) noexcept override {
+      _swiftPart.setRate(std::forward<decltype(rate)>(rate));
+    }
+    inline MixAudioMode getMixAudioMode() noexcept override {
+      auto __result = _swiftPart.getMixAudioMode();
+      return static_cast<MixAudioMode>(__result);
+    }
+    inline void setMixAudioMode(MixAudioMode mixAudioMode) noexcept override {
+      _swiftPart.setMixAudioMode(static_cast<int>(mixAudioMode));
+    }
+    inline IgnoreSilentSwitchMode getIgnoreSilentSwitchMode() noexcept override {
+      auto __result = _swiftPart.getIgnoreSilentSwitchMode();
+      return static_cast<IgnoreSilentSwitchMode>(__result);
+    }
+    inline void setIgnoreSilentSwitchMode(IgnoreSilentSwitchMode ignoreSilentSwitchMode) noexcept override {
+      _swiftPart.setIgnoreSilentSwitchMode(static_cast<int>(ignoreSilentSwitchMode));
+    }
+    inline bool getPlayInBackground() noexcept override {
+      return _swiftPart.getPlayInBackground();
+    }
+    inline void setPlayInBackground(bool playInBackground) noexcept override {
+      _swiftPart.setPlayInBackground(std::forward<decltype(playInBackground)>(playInBackground));
+    }
+    inline bool getPlayWhenInactive() noexcept override {
+      return _swiftPart.getPlayWhenInactive();
+    }
+    inline void setPlayWhenInactive(bool playWhenInactive) noexcept override {
+      _swiftPart.setPlayWhenInactive(std::forward<decltype(playWhenInactive)>(playWhenInactive));
+    }
+    inline bool getIsPlaying() noexcept override {
+      return _swiftPart.isPlaying();
+    }
+    inline std::optional<PlayerTrack> getSelectedTrack() noexcept override {
+      auto __result = _swiftPart.getSelectedTrack();
+      return __result;
+    }
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<void>> replaceSourceAsync(const std::optional<std::variant<nitro::NullType, std::shared_ptr<HybridVideoPlayerSourceSpec>>>& source) override {
+      auto __result = _swiftPart.replaceSourceAsync(source);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::vector<PlayerTrack> getAvailableTextTracks() override {
+      auto __result = _swiftPart.getAvailableTextTracks();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> initialize() override {
+      auto __result = _swiftPart.initialize();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> preload() override {
+      auto __result = _swiftPart.preload();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void play() override {
+      auto __result = _swiftPart.play();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void pause() override {
+      auto __result = _swiftPart.pause();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void seekBy(double time) override {
+      auto __result = _swiftPart.seekBy(std::forward<decltype(time)>(time));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void seekTo(double time) override {
+      auto __result = _swiftPart.seekTo(std::forward<decltype(time)>(time));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline AllPlayerTracks getAllPlayerTracks() override {
+      auto __result = _swiftPart.getAllPlayerTracks();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void selectTrackById(TrackType type, const std::optional<std::string>& id) override {
+      auto __result = _swiftPart.selectTrackById(static_cast<int>(type), id);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void selectTrackByIndex(TrackType type, std::optional<double> index) override {
+      auto __result = _swiftPart.selectTrackByIndex(static_cast<int>(type), index);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void resetForReuse() override {
+      auto __result = _swiftPart.resetForReuse();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void release() override {
+      auto __result = _swiftPart.release();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+
+  private:
+    ReactNativeVideo::HybridVideoPlayerSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::video

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

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

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

@@ -0,0 +1,78 @@
+///
+/// HybridVideoViewViewManagerFactorySpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridVideoViewViewManagerFactorySpec.hpp"
+
+// Forward declaration of `HybridVideoViewViewManagerFactorySpec_cxx` to properly resolve imports.
+namespace ReactNativeVideo { class HybridVideoViewViewManagerFactorySpec_cxx; }
+
+// Forward declaration of `HybridVideoViewViewManagerSpec` to properly resolve imports.
+namespace margelo::nitro::video { class HybridVideoViewViewManagerSpec; }
+
+#include <memory>
+#include "HybridVideoViewViewManagerSpec.hpp"
+
+#include "ReactNativeVideo-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::video {
+
+  /**
+   * The C++ part of HybridVideoViewViewManagerFactorySpec_cxx.swift.
+   *
+   * HybridVideoViewViewManagerFactorySpecSwift (C++) accesses HybridVideoViewViewManagerFactorySpec_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, HybridVideoViewViewManagerFactorySpec_cxx can directly inherit from the C++ class HybridVideoViewViewManagerFactorySpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridVideoViewViewManagerFactorySpecSwift: public virtual HybridVideoViewViewManagerFactorySpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridVideoViewViewManagerFactorySpecSwift(const ReactNativeVideo::HybridVideoViewViewManagerFactorySpec_cxx& swiftPart):
+      HybridObject(HybridVideoViewViewManagerFactorySpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline ReactNativeVideo::HybridVideoViewViewManagerFactorySpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<HybridVideoViewViewManagerSpec> createViewManager(double nitroId) override {
+      auto __result = _swiftPart.createViewManager(std::forward<decltype(nitroId)>(nitroId));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    ReactNativeVideo::HybridVideoViewViewManagerFactorySpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::video

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

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