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

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

@@ -0,0 +1,76 @@
+///
+/// ExternalForcedType.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 (ExternalForcedType).
+   */
+  enum class ExternalForcedType {
+    M3U8      SWIFT_NAME(m3u8) = 0,
+    MPD      SWIFT_NAME(mpd) = 1,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::video
+
+namespace margelo::nitro {
+
+  // C++ ExternalForcedType <> JS ExternalForcedType (union)
+  template <>
+  struct JSIConverter<margelo::nitro::video::ExternalForcedType> final {
+    static inline margelo::nitro::video::ExternalForcedType 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("m3u8"): return margelo::nitro::video::ExternalForcedType::M3U8;
+        case hashString("mpd"): return margelo::nitro::video::ExternalForcedType::MPD;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum ExternalForcedType - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::video::ExternalForcedType arg) {
+      switch (arg) {
+        case margelo::nitro::video::ExternalForcedType::M3U8: return JSIConverter<std::string>::toJSI(runtime, "m3u8");
+        case margelo::nitro::video::ExternalForcedType::MPD: return JSIConverter<std::string>::toJSI(runtime, "mpd");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert ExternalForcedType 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("m3u8"):
+        case hashString("mpd"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,39 @@
+///
+/// HybridVideoPlayerEventEmitterSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridVideoPlayerEventEmitterSpec.hpp"
+
+namespace margelo::nitro::video {
+
+  void HybridVideoPlayerEventEmitterSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("addOnAudioBecomingNoisyListener", &HybridVideoPlayerEventEmitterSpec::addOnAudioBecomingNoisyListener);
+      prototype.registerHybridMethod("addOnAudioFocusChangeListener", &HybridVideoPlayerEventEmitterSpec::addOnAudioFocusChangeListener);
+      prototype.registerHybridMethod("addOnBandwidthUpdateListener", &HybridVideoPlayerEventEmitterSpec::addOnBandwidthUpdateListener);
+      prototype.registerHybridMethod("addOnBufferListener", &HybridVideoPlayerEventEmitterSpec::addOnBufferListener);
+      prototype.registerHybridMethod("addOnControlsVisibleChangeListener", &HybridVideoPlayerEventEmitterSpec::addOnControlsVisibleChangeListener);
+      prototype.registerHybridMethod("addOnEndListener", &HybridVideoPlayerEventEmitterSpec::addOnEndListener);
+      prototype.registerHybridMethod("addOnExternalPlaybackChangeListener", &HybridVideoPlayerEventEmitterSpec::addOnExternalPlaybackChangeListener);
+      prototype.registerHybridMethod("addOnLoadListener", &HybridVideoPlayerEventEmitterSpec::addOnLoadListener);
+      prototype.registerHybridMethod("addOnLoadStartListener", &HybridVideoPlayerEventEmitterSpec::addOnLoadStartListener);
+      prototype.registerHybridMethod("addOnPlaybackStateChangeListener", &HybridVideoPlayerEventEmitterSpec::addOnPlaybackStateChangeListener);
+      prototype.registerHybridMethod("addOnPlaybackRateChangeListener", &HybridVideoPlayerEventEmitterSpec::addOnPlaybackRateChangeListener);
+      prototype.registerHybridMethod("addOnProgressListener", &HybridVideoPlayerEventEmitterSpec::addOnProgressListener);
+      prototype.registerHybridMethod("addOnReadyToDisplayListener", &HybridVideoPlayerEventEmitterSpec::addOnReadyToDisplayListener);
+      prototype.registerHybridMethod("addOnSeekListener", &HybridVideoPlayerEventEmitterSpec::addOnSeekListener);
+      prototype.registerHybridMethod("addOnStatusChangeListener", &HybridVideoPlayerEventEmitterSpec::addOnStatusChangeListener);
+      prototype.registerHybridMethod("addOnTimedMetadataListener", &HybridVideoPlayerEventEmitterSpec::addOnTimedMetadataListener);
+      prototype.registerHybridMethod("addOnTextTrackDataChangedListener", &HybridVideoPlayerEventEmitterSpec::addOnTextTrackDataChangedListener);
+      prototype.registerHybridMethod("addOnVolumeChangeListener", &HybridVideoPlayerEventEmitterSpec::addOnVolumeChangeListener);
+      prototype.registerHybridMethod("clearAllListeners", &HybridVideoPlayerEventEmitterSpec::clearAllListeners);
+    });
+  }
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,108 @@
+///
+/// HybridVideoPlayerEventEmitterSpec.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 `ListenerSubscription` to properly resolve imports.
+namespace margelo::nitro::video { struct ListenerSubscription; }
+// Forward declaration of `BandwidthData` to properly resolve imports.
+namespace margelo::nitro::video { struct BandwidthData; }
+// Forward declaration of `onLoadData` to properly resolve imports.
+namespace margelo::nitro::video { struct onLoadData; }
+// Forward declaration of `onLoadStartData` to properly resolve imports.
+namespace margelo::nitro::video { struct onLoadStartData; }
+// Forward declaration of `onPlaybackStateChangeData` to properly resolve imports.
+namespace margelo::nitro::video { struct onPlaybackStateChangeData; }
+// Forward declaration of `onProgressData` to properly resolve imports.
+namespace margelo::nitro::video { struct onProgressData; }
+// Forward declaration of `VideoPlayerStatus` to properly resolve imports.
+namespace margelo::nitro::video { enum class VideoPlayerStatus; }
+// Forward declaration of `TimedMetadata` to properly resolve imports.
+namespace margelo::nitro::video { struct TimedMetadata; }
+// Forward declaration of `onVolumeChangeData` to properly resolve imports.
+namespace margelo::nitro::video { struct onVolumeChangeData; }
+
+#include "ListenerSubscription.hpp"
+#include <functional>
+#include "BandwidthData.hpp"
+#include "onLoadData.hpp"
+#include "onLoadStartData.hpp"
+#include "onPlaybackStateChangeData.hpp"
+#include "onProgressData.hpp"
+#include "VideoPlayerStatus.hpp"
+#include "TimedMetadata.hpp"
+#include <string>
+#include <vector>
+#include "onVolumeChangeData.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `VideoPlayerEventEmitter`
+   * Inherit this class to create instances of `HybridVideoPlayerEventEmitterSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridVideoPlayerEventEmitter: public HybridVideoPlayerEventEmitterSpec {
+   * public:
+   *   HybridVideoPlayerEventEmitter(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridVideoPlayerEventEmitterSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridVideoPlayerEventEmitterSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridVideoPlayerEventEmitterSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual ListenerSubscription addOnAudioBecomingNoisyListener(const std::function<void()>& listener) = 0;
+      virtual ListenerSubscription addOnAudioFocusChangeListener(const std::function<void(bool /* hasAudioFocus */)>& listener) = 0;
+      virtual ListenerSubscription addOnBandwidthUpdateListener(const std::function<void(const BandwidthData& /* data */)>& listener) = 0;
+      virtual ListenerSubscription addOnBufferListener(const std::function<void(bool /* buffering */)>& listener) = 0;
+      virtual ListenerSubscription addOnControlsVisibleChangeListener(const std::function<void(bool /* visible */)>& listener) = 0;
+      virtual ListenerSubscription addOnEndListener(const std::function<void()>& listener) = 0;
+      virtual ListenerSubscription addOnExternalPlaybackChangeListener(const std::function<void(bool /* externalPlaybackActive */)>& listener) = 0;
+      virtual ListenerSubscription addOnLoadListener(const std::function<void(const onLoadData& /* data */)>& listener) = 0;
+      virtual ListenerSubscription addOnLoadStartListener(const std::function<void(const onLoadStartData& /* data */)>& listener) = 0;
+      virtual ListenerSubscription addOnPlaybackStateChangeListener(const std::function<void(const onPlaybackStateChangeData& /* data */)>& listener) = 0;
+      virtual ListenerSubscription addOnPlaybackRateChangeListener(const std::function<void(double /* rate */)>& listener) = 0;
+      virtual ListenerSubscription addOnProgressListener(const std::function<void(const onProgressData& /* data */)>& listener) = 0;
+      virtual ListenerSubscription addOnReadyToDisplayListener(const std::function<void()>& listener) = 0;
+      virtual ListenerSubscription addOnSeekListener(const std::function<void(double /* position */)>& listener) = 0;
+      virtual ListenerSubscription addOnStatusChangeListener(const std::function<void(VideoPlayerStatus /* status */)>& listener) = 0;
+      virtual ListenerSubscription addOnTimedMetadataListener(const std::function<void(const TimedMetadata& /* data */)>& listener) = 0;
+      virtual ListenerSubscription addOnTextTrackDataChangedListener(const std::function<void(const std::vector<std::string>& /* data */)>& listener) = 0;
+      virtual ListenerSubscription addOnVolumeChangeListener(const std::function<void(const onVolumeChangeData& /* data */)>& listener) = 0;
+      virtual void clearAllListeners() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "VideoPlayerEventEmitter";
+  };
+
+} // namespace margelo::nitro::video

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

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

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

@@ -0,0 +1,68 @@
+///
+/// HybridVideoPlayerFactorySpec.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 `HybridVideoPlayerSourceSpec` to properly resolve imports.
+namespace margelo::nitro::video { class HybridVideoPlayerSourceSpec; }
+
+#include <memory>
+#include "HybridVideoPlayerSpec.hpp"
+#include "HybridVideoPlayerSourceSpec.hpp"
+#include <optional>
+
+namespace margelo::nitro::video {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `VideoPlayerFactory`
+   * Inherit this class to create instances of `HybridVideoPlayerFactorySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridVideoPlayerFactory: public HybridVideoPlayerFactorySpec {
+   * public:
+   *   HybridVideoPlayerFactory(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridVideoPlayerFactorySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridVideoPlayerFactorySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridVideoPlayerFactorySpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<HybridVideoPlayerSpec> createPlayer(const std::optional<std::shared_ptr<HybridVideoPlayerSourceSpec>>& source) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "VideoPlayerFactory";
+  };
+
+} // namespace margelo::nitro::video

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

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

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

@@ -0,0 +1,69 @@
+///
+/// HybridVideoPlayerSourceFactorySpec.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 `NativeVideoConfig` to properly resolve imports.
+namespace margelo::nitro::video { struct NativeVideoConfig; }
+
+#include <memory>
+#include "HybridVideoPlayerSourceSpec.hpp"
+#include <string>
+#include "NativeVideoConfig.hpp"
+
+namespace margelo::nitro::video {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `VideoPlayerSourceFactory`
+   * Inherit this class to create instances of `HybridVideoPlayerSourceFactorySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridVideoPlayerSourceFactory: public HybridVideoPlayerSourceFactorySpec {
+   * public:
+   *   HybridVideoPlayerSourceFactory(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridVideoPlayerSourceFactorySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridVideoPlayerSourceFactorySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridVideoPlayerSourceFactorySpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<HybridVideoPlayerSourceSpec> fromUri(const std::string& uri) = 0;
+      virtual std::shared_ptr<HybridVideoPlayerSourceSpec> fromVideoConfig(const NativeVideoConfig& config) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "VideoPlayerSourceFactory";
+  };
+
+} // namespace margelo::nitro::video

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

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

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

@@ -0,0 +1,69 @@
+///
+/// HybridVideoPlayerSourceSpec.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 `NativeVideoConfig` to properly resolve imports.
+namespace margelo::nitro::video { struct NativeVideoConfig; }
+// Forward declaration of `VideoInformation` to properly resolve imports.
+namespace margelo::nitro::video { struct VideoInformation; }
+
+#include <string>
+#include "NativeVideoConfig.hpp"
+#include "VideoInformation.hpp"
+#include <NitroModules/Promise.hpp>
+
+namespace margelo::nitro::video {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `VideoPlayerSource`
+   * Inherit this class to create instances of `HybridVideoPlayerSourceSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridVideoPlayerSource: public HybridVideoPlayerSourceSpec {
+   * public:
+   *   HybridVideoPlayerSource(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridVideoPlayerSourceSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridVideoPlayerSourceSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridVideoPlayerSourceSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getUri() = 0;
+      virtual NativeVideoConfig getConfig() = 0;
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<VideoInformation>> getAssetInformationAsync() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "VideoPlayerSource";
+  };
+
+} // namespace margelo::nitro::video

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

@@ -0,0 +1,63 @@
+///
+/// HybridVideoPlayerSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridVideoPlayerSpec.hpp"
+
+namespace margelo::nitro::video {
+
+  void HybridVideoPlayerSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("source", &HybridVideoPlayerSpec::getSource);
+      prototype.registerHybridGetter("eventEmitter", &HybridVideoPlayerSpec::getEventEmitter);
+      prototype.registerHybridGetter("showNotificationControls", &HybridVideoPlayerSpec::getShowNotificationControls);
+      prototype.registerHybridSetter("showNotificationControls", &HybridVideoPlayerSpec::setShowNotificationControls);
+      prototype.registerHybridGetter("status", &HybridVideoPlayerSpec::getStatus);
+      prototype.registerHybridGetter("duration", &HybridVideoPlayerSpec::getDuration);
+      prototype.registerHybridGetter("volume", &HybridVideoPlayerSpec::getVolume);
+      prototype.registerHybridSetter("volume", &HybridVideoPlayerSpec::setVolume);
+      prototype.registerHybridGetter("currentTime", &HybridVideoPlayerSpec::getCurrentTime);
+      prototype.registerHybridSetter("currentTime", &HybridVideoPlayerSpec::setCurrentTime);
+      prototype.registerHybridGetter("progressEventInterval", &HybridVideoPlayerSpec::getProgressEventInterval);
+      prototype.registerHybridSetter("progressEventInterval", &HybridVideoPlayerSpec::setProgressEventInterval);
+      prototype.registerHybridGetter("subtitleDelay", &HybridVideoPlayerSpec::getSubtitleDelay);
+      prototype.registerHybridSetter("subtitleDelay", &HybridVideoPlayerSpec::setSubtitleDelay);
+      prototype.registerHybridGetter("muted", &HybridVideoPlayerSpec::getMuted);
+      prototype.registerHybridSetter("muted", &HybridVideoPlayerSpec::setMuted);
+      prototype.registerHybridGetter("loop", &HybridVideoPlayerSpec::getLoop);
+      prototype.registerHybridSetter("loop", &HybridVideoPlayerSpec::setLoop);
+      prototype.registerHybridGetter("rate", &HybridVideoPlayerSpec::getRate);
+      prototype.registerHybridSetter("rate", &HybridVideoPlayerSpec::setRate);
+      prototype.registerHybridGetter("mixAudioMode", &HybridVideoPlayerSpec::getMixAudioMode);
+      prototype.registerHybridSetter("mixAudioMode", &HybridVideoPlayerSpec::setMixAudioMode);
+      prototype.registerHybridGetter("ignoreSilentSwitchMode", &HybridVideoPlayerSpec::getIgnoreSilentSwitchMode);
+      prototype.registerHybridSetter("ignoreSilentSwitchMode", &HybridVideoPlayerSpec::setIgnoreSilentSwitchMode);
+      prototype.registerHybridGetter("playInBackground", &HybridVideoPlayerSpec::getPlayInBackground);
+      prototype.registerHybridSetter("playInBackground", &HybridVideoPlayerSpec::setPlayInBackground);
+      prototype.registerHybridGetter("playWhenInactive", &HybridVideoPlayerSpec::getPlayWhenInactive);
+      prototype.registerHybridSetter("playWhenInactive", &HybridVideoPlayerSpec::setPlayWhenInactive);
+      prototype.registerHybridGetter("isPlaying", &HybridVideoPlayerSpec::getIsPlaying);
+      prototype.registerHybridGetter("selectedTrack", &HybridVideoPlayerSpec::getSelectedTrack);
+      prototype.registerHybridMethod("replaceSourceAsync", &HybridVideoPlayerSpec::replaceSourceAsync);
+      prototype.registerHybridMethod("getAvailableTextTracks", &HybridVideoPlayerSpec::getAvailableTextTracks);
+      prototype.registerHybridMethod("initialize", &HybridVideoPlayerSpec::initialize);
+      prototype.registerHybridMethod("preload", &HybridVideoPlayerSpec::preload);
+      prototype.registerHybridMethod("play", &HybridVideoPlayerSpec::play);
+      prototype.registerHybridMethod("pause", &HybridVideoPlayerSpec::pause);
+      prototype.registerHybridMethod("seekBy", &HybridVideoPlayerSpec::seekBy);
+      prototype.registerHybridMethod("seekTo", &HybridVideoPlayerSpec::seekTo);
+      prototype.registerHybridMethod("getAllPlayerTracks", &HybridVideoPlayerSpec::getAllPlayerTracks);
+      prototype.registerHybridMethod("selectTrackById", &HybridVideoPlayerSpec::selectTrackById);
+      prototype.registerHybridMethod("selectTrackByIndex", &HybridVideoPlayerSpec::selectTrackByIndex);
+      prototype.registerHybridMethod("resetForReuse", &HybridVideoPlayerSpec::resetForReuse);
+      prototype.registerHybridMethod("release", &HybridVideoPlayerSpec::release);
+    });
+  }
+
+} // namespace margelo::nitro::video