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

package/nitrogen/generated/shared/c++/HybridVideoPlayerSpec.hpp

@@ -0,0 +1,132 @@
+///
+/// HybridVideoPlayerSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// 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 `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 <NitroModules/Promise.hpp>
+#include <NitroModules/Null.hpp>
+#include <variant>
+#include <vector>
+#include "AllPlayerTracks.hpp"
+#include "TrackType.hpp"
+#include <string>
+
+namespace margelo::nitro::video {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `VideoPlayer`
+   * Inherit this class to create instances of `HybridVideoPlayerSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridVideoPlayer: public HybridVideoPlayerSpec {
+   * public:
+   *   HybridVideoPlayer(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridVideoPlayerSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridVideoPlayerSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridVideoPlayerSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::shared_ptr<HybridVideoPlayerSourceSpec> getSource() = 0;
+      virtual std::shared_ptr<HybridVideoPlayerEventEmitterSpec> getEventEmitter() = 0;
+      virtual bool getShowNotificationControls() = 0;
+      virtual void setShowNotificationControls(bool showNotificationControls) = 0;
+      virtual VideoPlayerStatus getStatus() = 0;
+      virtual double getDuration() = 0;
+      virtual double getVolume() = 0;
+      virtual void setVolume(double volume) = 0;
+      virtual double getCurrentTime() = 0;
+      virtual void setCurrentTime(double currentTime) = 0;
+      virtual double getProgressEventInterval() = 0;
+      virtual void setProgressEventInterval(double progressEventInterval) = 0;
+      virtual int64_t getSubtitleDelay() = 0;
+      virtual void setSubtitleDelay(int64_t subtitleDelay) = 0;
+      virtual bool getMuted() = 0;
+      virtual void setMuted(bool muted) = 0;
+      virtual bool getLoop() = 0;
+      virtual void setLoop(bool loop) = 0;
+      virtual double getRate() = 0;
+      virtual void setRate(double rate) = 0;
+      virtual MixAudioMode getMixAudioMode() = 0;
+      virtual void setMixAudioMode(MixAudioMode mixAudioMode) = 0;
+      virtual IgnoreSilentSwitchMode getIgnoreSilentSwitchMode() = 0;
+      virtual void setIgnoreSilentSwitchMode(IgnoreSilentSwitchMode ignoreSilentSwitchMode) = 0;
+      virtual bool getPlayInBackground() = 0;
+      virtual void setPlayInBackground(bool playInBackground) = 0;
+      virtual bool getPlayWhenInactive() = 0;
+      virtual void setPlayWhenInactive(bool playWhenInactive) = 0;
+      virtual bool getIsPlaying() = 0;
+      virtual std::optional<PlayerTrack> getSelectedTrack() = 0;
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> replaceSourceAsync(const std::optional<std::variant<nitro::NullType, std::shared_ptr<HybridVideoPlayerSourceSpec>>>& source) = 0;
+      virtual std::vector<PlayerTrack> getAvailableTextTracks() = 0;
+      virtual std::shared_ptr<Promise<void>> initialize() = 0;
+      virtual std::shared_ptr<Promise<void>> preload() = 0;
+      virtual void play() = 0;
+      virtual void pause() = 0;
+      virtual void seekBy(double time) = 0;
+      virtual void seekTo(double time) = 0;
+      virtual AllPlayerTracks getAllPlayerTracks() = 0;
+      virtual void selectTrackById(TrackType type, const std::optional<std::string>& id) = 0;
+      virtual void selectTrackByIndex(TrackType type, std::optional<double> index) = 0;
+      virtual void resetForReuse() = 0;
+      virtual void release() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "VideoPlayer";
+  };
+
+} // namespace margelo::nitro::video

package/nitrogen/generated/shared/c++/HybridVideoViewViewManagerFactorySpec.cpp

@@ -0,0 +1,21 @@
+///
+/// HybridVideoViewViewManagerFactorySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridVideoViewViewManagerFactorySpec.hpp"
+
+namespace margelo::nitro::video {
+
+  void HybridVideoViewViewManagerFactorySpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("createViewManager", &HybridVideoViewViewManagerFactorySpec::createViewManager);
+    });
+  }
+
+} // namespace margelo::nitro::video

package/nitrogen/generated/shared/c++/HybridVideoViewViewManagerFactorySpec.hpp

@@ -0,0 +1,64 @@
+///
+/// HybridVideoViewViewManagerFactorySpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridVideoViewViewManagerSpec` to properly resolve imports.
+namespace margelo::nitro::video { class HybridVideoViewViewManagerSpec; }
+
+#include <memory>
+#include "HybridVideoViewViewManagerSpec.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `VideoViewViewManagerFactory`
+   * Inherit this class to create instances of `HybridVideoViewViewManagerFactorySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridVideoViewViewManagerFactory: public HybridVideoViewViewManagerFactorySpec {
+   * public:
+   *   HybridVideoViewViewManagerFactory(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridVideoViewViewManagerFactorySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridVideoViewViewManagerFactorySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridVideoViewViewManagerFactorySpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<HybridVideoViewViewManagerSpec> createViewManager(double nitroId) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "VideoViewViewManagerFactory";
+  };
+
+} // namespace margelo::nitro::video

package/nitrogen/generated/shared/c++/HybridVideoViewViewManagerSpec.cpp

@@ -0,0 +1,46 @@
+///
+/// HybridVideoViewViewManagerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridVideoViewViewManagerSpec.hpp"
+
+namespace margelo::nitro::video {
+
+  void HybridVideoViewViewManagerSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("player", &HybridVideoViewViewManagerSpec::getPlayer);
+      prototype.registerHybridSetter("player", &HybridVideoViewViewManagerSpec::setPlayer);
+      prototype.registerHybridGetter("controls", &HybridVideoViewViewManagerSpec::getControls);
+      prototype.registerHybridSetter("controls", &HybridVideoViewViewManagerSpec::setControls);
+      prototype.registerHybridGetter("pictureInPicture", &HybridVideoViewViewManagerSpec::getPictureInPicture);
+      prototype.registerHybridSetter("pictureInPicture", &HybridVideoViewViewManagerSpec::setPictureInPicture);
+      prototype.registerHybridGetter("autoEnterPictureInPicture", &HybridVideoViewViewManagerSpec::getAutoEnterPictureInPicture);
+      prototype.registerHybridSetter("autoEnterPictureInPicture", &HybridVideoViewViewManagerSpec::setAutoEnterPictureInPicture);
+      prototype.registerHybridGetter("resizeMode", &HybridVideoViewViewManagerSpec::getResizeMode);
+      prototype.registerHybridSetter("resizeMode", &HybridVideoViewViewManagerSpec::setResizeMode);
+      prototype.registerHybridGetter("keepScreenAwake", &HybridVideoViewViewManagerSpec::getKeepScreenAwake);
+      prototype.registerHybridSetter("keepScreenAwake", &HybridVideoViewViewManagerSpec::setKeepScreenAwake);
+      prototype.registerHybridGetter("surfaceType", &HybridVideoViewViewManagerSpec::getSurfaceType);
+      prototype.registerHybridSetter("surfaceType", &HybridVideoViewViewManagerSpec::setSurfaceType);
+      prototype.registerHybridMethod("enterFullscreen", &HybridVideoViewViewManagerSpec::enterFullscreen);
+      prototype.registerHybridMethod("exitFullscreen", &HybridVideoViewViewManagerSpec::exitFullscreen);
+      prototype.registerHybridMethod("enterPictureInPicture", &HybridVideoViewViewManagerSpec::enterPictureInPicture);
+      prototype.registerHybridMethod("exitPictureInPicture", &HybridVideoViewViewManagerSpec::exitPictureInPicture);
+      prototype.registerHybridMethod("canEnterPictureInPicture", &HybridVideoViewViewManagerSpec::canEnterPictureInPicture);
+      prototype.registerHybridMethod("addOnPictureInPictureChangeListener", &HybridVideoViewViewManagerSpec::addOnPictureInPictureChangeListener);
+      prototype.registerHybridMethod("addOnFullscreenChangeListener", &HybridVideoViewViewManagerSpec::addOnFullscreenChangeListener);
+      prototype.registerHybridMethod("addWillEnterFullscreenListener", &HybridVideoViewViewManagerSpec::addWillEnterFullscreenListener);
+      prototype.registerHybridMethod("addWillExitFullscreenListener", &HybridVideoViewViewManagerSpec::addWillExitFullscreenListener);
+      prototype.registerHybridMethod("addWillEnterPictureInPictureListener", &HybridVideoViewViewManagerSpec::addWillEnterPictureInPictureListener);
+      prototype.registerHybridMethod("addWillExitPictureInPictureListener", &HybridVideoViewViewManagerSpec::addWillExitPictureInPictureListener);
+      prototype.registerHybridMethod("clearAllListeners", &HybridVideoViewViewManagerSpec::clearAllListeners);
+    });
+  }
+
+} // namespace margelo::nitro::video

package/nitrogen/generated/shared/c++/HybridVideoViewViewManagerSpec.hpp

@@ -0,0 +1,99 @@
+///
+/// HybridVideoViewViewManagerSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridVideoPlayerSpec` to properly resolve imports.
+namespace margelo::nitro::video { class HybridVideoPlayerSpec; }
+// Forward declaration of `ResizeMode` to properly resolve imports.
+namespace margelo::nitro::video { enum class ResizeMode; }
+// Forward declaration of `SurfaceType` to properly resolve imports.
+namespace margelo::nitro::video { enum class SurfaceType; }
+// Forward declaration of `ListenerSubscription` to properly resolve imports.
+namespace margelo::nitro::video { struct ListenerSubscription; }
+
+#include <memory>
+#include "HybridVideoPlayerSpec.hpp"
+#include <optional>
+#include "ResizeMode.hpp"
+#include "SurfaceType.hpp"
+#include "ListenerSubscription.hpp"
+#include <functional>
+
+namespace margelo::nitro::video {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `VideoViewViewManager`
+   * Inherit this class to create instances of `HybridVideoViewViewManagerSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridVideoViewViewManager: public HybridVideoViewViewManagerSpec {
+   * public:
+   *   HybridVideoViewViewManager(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridVideoViewViewManagerSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridVideoViewViewManagerSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridVideoViewViewManagerSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::optional<std::shared_ptr<HybridVideoPlayerSpec>> getPlayer() = 0;
+      virtual void setPlayer(const std::optional<std::shared_ptr<HybridVideoPlayerSpec>>& player) = 0;
+      virtual bool getControls() = 0;
+      virtual void setControls(bool controls) = 0;
+      virtual bool getPictureInPicture() = 0;
+      virtual void setPictureInPicture(bool pictureInPicture) = 0;
+      virtual bool getAutoEnterPictureInPicture() = 0;
+      virtual void setAutoEnterPictureInPicture(bool autoEnterPictureInPicture) = 0;
+      virtual ResizeMode getResizeMode() = 0;
+      virtual void setResizeMode(ResizeMode resizeMode) = 0;
+      virtual bool getKeepScreenAwake() = 0;
+      virtual void setKeepScreenAwake(bool keepScreenAwake) = 0;
+      virtual SurfaceType getSurfaceType() = 0;
+      virtual void setSurfaceType(SurfaceType surfaceType) = 0;
+
+    public:
+      // Methods
+      virtual void enterFullscreen() = 0;
+      virtual void exitFullscreen() = 0;
+      virtual void enterPictureInPicture() = 0;
+      virtual void exitPictureInPicture() = 0;
+      virtual bool canEnterPictureInPicture() = 0;
+      virtual ListenerSubscription addOnPictureInPictureChangeListener(const std::function<void(bool /* isInPictureInPicture */)>& listener) = 0;
+      virtual ListenerSubscription addOnFullscreenChangeListener(const std::function<void(bool /* fullscreen */)>& listener) = 0;
+      virtual ListenerSubscription addWillEnterFullscreenListener(const std::function<void()>& listener) = 0;
+      virtual ListenerSubscription addWillExitFullscreenListener(const std::function<void()>& listener) = 0;
+      virtual ListenerSubscription addWillEnterPictureInPictureListener(const std::function<void()>& listener) = 0;
+      virtual ListenerSubscription addWillExitPictureInPictureListener(const std::function<void()>& listener) = 0;
+      virtual void clearAllListeners() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "VideoViewViewManager";
+  };
+
+} // namespace margelo::nitro::video

package/nitrogen/generated/shared/c++/IgnoreSilentSwitchMode.hpp

@@ -0,0 +1,80 @@
+///
+/// IgnoreSilentSwitchMode.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+namespace margelo::nitro::video {
+
+  /**
+   * An enum which can be represented as a JavaScript union (IgnoreSilentSwitchMode).
+   */
+  enum class IgnoreSilentSwitchMode {
+    AUTO      SWIFT_NAME(auto) = 0,
+    IGNORE      SWIFT_NAME(ignore) = 1,
+    OBEY      SWIFT_NAME(obey) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::video
+
+namespace margelo::nitro {
+
+  // C++ IgnoreSilentSwitchMode <> JS IgnoreSilentSwitchMode (union)
+  template <>
+  struct JSIConverter<margelo::nitro::video::IgnoreSilentSwitchMode> final {
+    static inline margelo::nitro::video::IgnoreSilentSwitchMode fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("auto"): return margelo::nitro::video::IgnoreSilentSwitchMode::AUTO;
+        case hashString("ignore"): return margelo::nitro::video::IgnoreSilentSwitchMode::IGNORE;
+        case hashString("obey"): return margelo::nitro::video::IgnoreSilentSwitchMode::OBEY;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum IgnoreSilentSwitchMode - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::video::IgnoreSilentSwitchMode arg) {
+      switch (arg) {
+        case margelo::nitro::video::IgnoreSilentSwitchMode::AUTO: return JSIConverter<std::string>::toJSI(runtime, "auto");
+        case margelo::nitro::video::IgnoreSilentSwitchMode::IGNORE: return JSIConverter<std::string>::toJSI(runtime, "ignore");
+        case margelo::nitro::video::IgnoreSilentSwitchMode::OBEY: return JSIConverter<std::string>::toJSI(runtime, "obey");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert IgnoreSilentSwitchMode to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("auto"):
+        case hashString("ignore"):
+        case hashString("obey"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/ListenerSubscription.hpp

@@ -0,0 +1,75 @@
+///
+/// ListenerSubscription.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <functional>
+
+namespace margelo::nitro::video {
+
+  /**
+   * A struct which can be represented as a JavaScript object (ListenerSubscription).
+   */
+  struct ListenerSubscription {
+  public:
+    std::function<void()> remove     SWIFT_PRIVATE;
+
+  public:
+    ListenerSubscription() = default;
+    explicit ListenerSubscription(std::function<void()> remove): remove(remove) {}
+  };
+
+} // namespace margelo::nitro::video
+
+namespace margelo::nitro {
+
+  // C++ ListenerSubscription <> JS ListenerSubscription (object)
+  template <>
+  struct JSIConverter<margelo::nitro::video::ListenerSubscription> final {
+    static inline margelo::nitro::video::ListenerSubscription fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::video::ListenerSubscription(
+        JSIConverter<std::function<void()>>::fromJSI(runtime, obj.getProperty(runtime, "remove"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::video::ListenerSubscription& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "remove", JSIConverter<std::function<void()>>::toJSI(runtime, arg.remove));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::function<void()>>::canConvert(runtime, obj.getProperty(runtime, "remove"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/LivePlaybackParams.hpp

@@ -0,0 +1,91 @@
+///
+/// LivePlaybackParams.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <optional>
+
+namespace margelo::nitro::video {
+
+  /**
+   * A struct which can be represented as a JavaScript object (LivePlaybackParams).
+   */
+  struct LivePlaybackParams {
+  public:
+    std::optional<double> minPlaybackSpeed     SWIFT_PRIVATE;
+    std::optional<double> maxPlaybackSpeed     SWIFT_PRIVATE;
+    std::optional<double> maxOffsetMs     SWIFT_PRIVATE;
+    std::optional<double> minOffsetMs     SWIFT_PRIVATE;
+    std::optional<double> targetOffsetMs     SWIFT_PRIVATE;
+
+  public:
+    LivePlaybackParams() = default;
+    explicit LivePlaybackParams(std::optional<double> minPlaybackSpeed, std::optional<double> maxPlaybackSpeed, std::optional<double> maxOffsetMs, std::optional<double> minOffsetMs, std::optional<double> targetOffsetMs): minPlaybackSpeed(minPlaybackSpeed), maxPlaybackSpeed(maxPlaybackSpeed), maxOffsetMs(maxOffsetMs), minOffsetMs(minOffsetMs), targetOffsetMs(targetOffsetMs) {}
+  };
+
+} // namespace margelo::nitro::video
+
+namespace margelo::nitro {
+
+  // C++ LivePlaybackParams <> JS LivePlaybackParams (object)
+  template <>
+  struct JSIConverter<margelo::nitro::video::LivePlaybackParams> final {
+    static inline margelo::nitro::video::LivePlaybackParams fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::video::LivePlaybackParams(
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "minPlaybackSpeed")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "maxPlaybackSpeed")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "maxOffsetMs")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "minOffsetMs")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "targetOffsetMs"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::video::LivePlaybackParams& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "minPlaybackSpeed", JSIConverter<std::optional<double>>::toJSI(runtime, arg.minPlaybackSpeed));
+      obj.setProperty(runtime, "maxPlaybackSpeed", JSIConverter<std::optional<double>>::toJSI(runtime, arg.maxPlaybackSpeed));
+      obj.setProperty(runtime, "maxOffsetMs", JSIConverter<std::optional<double>>::toJSI(runtime, arg.maxOffsetMs));
+      obj.setProperty(runtime, "minOffsetMs", JSIConverter<std::optional<double>>::toJSI(runtime, arg.minOffsetMs));
+      obj.setProperty(runtime, "targetOffsetMs", JSIConverter<std::optional<double>>::toJSI(runtime, arg.targetOffsetMs));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "minPlaybackSpeed"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "maxPlaybackSpeed"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "maxOffsetMs"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "minOffsetMs"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "targetOffsetMs"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro