react-native-webrtc-nitro 1.0.0

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

@@ -0,0 +1,70 @@
+///
+/// HybridMediaStreamSpec.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 `HybridMediaStreamTrackSpec` to properly resolve imports.
+namespace margelo::nitro::webrtc { class HybridMediaStreamTrackSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridMediaStreamTrackSpec.hpp"
+#include <vector>
+
+namespace margelo::nitro::webrtc {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `MediaStream`
+   * Inherit this class to create instances of `HybridMediaStreamSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridMediaStream: public HybridMediaStreamSpec {
+   * public:
+   *   HybridMediaStream(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridMediaStreamSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridMediaStreamSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridMediaStreamSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getId() = 0;
+
+    public:
+      // Methods
+      virtual std::vector<std::shared_ptr<HybridMediaStreamTrackSpec>> getTracks() = 0;
+      virtual void addTrack(const std::shared_ptr<HybridMediaStreamTrackSpec>& track) = 0;
+      virtual void removeTrack(const std::shared_ptr<HybridMediaStreamTrackSpec>& track) = 0;
+      virtual std::vector<std::shared_ptr<HybridMediaStreamTrackSpec>> getAudioTracks() = 0;
+      virtual std::vector<std::shared_ptr<HybridMediaStreamTrackSpec>> getVideoTracks() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "MediaStream";
+  };
+
+} // namespace margelo::nitro::webrtc

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

@@ -0,0 +1,28 @@
+///
+/// HybridMediaStreamTrackSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridMediaStreamTrackSpec.hpp"
+
+namespace margelo::nitro::webrtc {
+
+  void HybridMediaStreamTrackSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("id", &HybridMediaStreamTrackSpec::getId);
+      prototype.registerHybridGetter("kind", &HybridMediaStreamTrackSpec::getKind);
+      prototype.registerHybridGetter("readyState", &HybridMediaStreamTrackSpec::getReadyState);
+      prototype.registerHybridGetter("enabled", &HybridMediaStreamTrackSpec::getEnabled);
+      prototype.registerHybridSetter("enabled", &HybridMediaStreamTrackSpec::setEnabled);
+      prototype.registerHybridGetter("_srcPipeId", &HybridMediaStreamTrackSpec::get_srcPipeId);
+      prototype.registerHybridGetter("_dstPipeId", &HybridMediaStreamTrackSpec::get_dstPipeId);
+      prototype.registerHybridMethod("stop", &HybridMediaStreamTrackSpec::stop);
+    });
+  }
+
+} // namespace margelo::nitro::webrtc

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

@@ -0,0 +1,70 @@
+///
+/// HybridMediaStreamTrackSpec.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 `MediaStreamTrackState` to properly resolve imports.
+namespace margelo::nitro::webrtc { enum class MediaStreamTrackState; }
+
+#include <string>
+#include "MediaStreamTrackState.hpp"
+
+namespace margelo::nitro::webrtc {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `MediaStreamTrack`
+   * Inherit this class to create instances of `HybridMediaStreamTrackSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridMediaStreamTrack: public HybridMediaStreamTrackSpec {
+   * public:
+   *   HybridMediaStreamTrack(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridMediaStreamTrackSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridMediaStreamTrackSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridMediaStreamTrackSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getId() = 0;
+      virtual std::string getKind() = 0;
+      virtual MediaStreamTrackState getReadyState() = 0;
+      virtual bool getEnabled() = 0;
+      virtual void setEnabled(bool enabled) = 0;
+      virtual std::string get_srcPipeId() = 0;
+      virtual std::string get_dstPipeId() = 0;
+
+    public:
+      // Methods
+      virtual void stop() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "MediaStreamTrack";
+  };
+
+} // namespace margelo::nitro::webrtc

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

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

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

@@ -0,0 +1,63 @@
+///
+/// HybridMicrophoneSpec.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
+
+
+
+#include <NitroModules/Promise.hpp>
+#include <string>
+
+namespace margelo::nitro::webrtc {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Microphone`
+   * Inherit this class to create instances of `HybridMicrophoneSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridMicrophone: public HybridMicrophoneSpec {
+   * public:
+   *   HybridMicrophone(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridMicrophoneSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridMicrophoneSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridMicrophoneSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> open(const std::string& pipeId) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Microphone";
+  };
+
+} // namespace margelo::nitro::webrtc

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

@@ -0,0 +1,41 @@
+///
+/// HybridRTCPeerConnectionSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridRTCPeerConnectionSpec.hpp"
+
+namespace margelo::nitro::webrtc {
+
+  void HybridRTCPeerConnectionSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("connectionState", &HybridRTCPeerConnectionSpec::getConnectionState);
+      prototype.registerHybridGetter("iceGatheringState", &HybridRTCPeerConnectionSpec::getIceGatheringState);
+      prototype.registerHybridGetter("localDescription", &HybridRTCPeerConnectionSpec::getLocalDescription);
+      prototype.registerHybridGetter("remoteDescription", &HybridRTCPeerConnectionSpec::getRemoteDescription);
+      prototype.registerHybridGetter("onconnectionstatechange", &HybridRTCPeerConnectionSpec::getOnconnectionstatechange);
+      prototype.registerHybridSetter("onconnectionstatechange", &HybridRTCPeerConnectionSpec::setOnconnectionstatechange);
+      prototype.registerHybridGetter("onicegatheringstatechange", &HybridRTCPeerConnectionSpec::getOnicegatheringstatechange);
+      prototype.registerHybridSetter("onicegatheringstatechange", &HybridRTCPeerConnectionSpec::setOnicegatheringstatechange);
+      prototype.registerHybridGetter("onicecandidate", &HybridRTCPeerConnectionSpec::getOnicecandidate);
+      prototype.registerHybridSetter("onicecandidate", &HybridRTCPeerConnectionSpec::setOnicecandidate);
+      prototype.registerHybridGetter("ontrack", &HybridRTCPeerConnectionSpec::getOntrack);
+      prototype.registerHybridSetter("ontrack", &HybridRTCPeerConnectionSpec::setOntrack);
+      prototype.registerHybridMethod("setConfiguration", &HybridRTCPeerConnectionSpec::setConfiguration);
+      prototype.registerHybridMethod("close", &HybridRTCPeerConnectionSpec::close);
+      prototype.registerHybridMethod("setLocalDescription", &HybridRTCPeerConnectionSpec::setLocalDescription);
+      prototype.registerHybridMethod("setRemoteDescription", &HybridRTCPeerConnectionSpec::setRemoteDescription);
+      prototype.registerHybridMethod("addIceCandidate", &HybridRTCPeerConnectionSpec::addIceCandidate);
+      prototype.registerHybridMethod("addTransceiver", &HybridRTCPeerConnectionSpec::addTransceiver);
+      prototype.registerHybridMethod("getTransceivers", &HybridRTCPeerConnectionSpec::getTransceivers);
+      prototype.registerHybridMethod("createOffer", &HybridRTCPeerConnectionSpec::createOffer);
+      prototype.registerHybridMethod("createAnswer", &HybridRTCPeerConnectionSpec::createAnswer);
+    });
+  }
+
+} // namespace margelo::nitro::webrtc

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

@@ -0,0 +1,120 @@
+///
+/// HybridRTCPeerConnectionSpec.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 `RTCPeerConnectionState` to properly resolve imports.
+namespace margelo::nitro::webrtc { enum class RTCPeerConnectionState; }
+// Forward declaration of `RTCIceGatheringState` to properly resolve imports.
+namespace margelo::nitro::webrtc { enum class RTCIceGatheringState; }
+// Forward declaration of `Event` to properly resolve imports.
+namespace margelo::nitro::webrtc { struct Event; }
+// Forward declaration of `RTCPeerConnectionIceEvent` to properly resolve imports.
+namespace margelo::nitro::webrtc { struct RTCPeerConnectionIceEvent; }
+// Forward declaration of `RTCTrackEvent` to properly resolve imports.
+namespace margelo::nitro::webrtc { struct RTCTrackEvent; }
+// Forward declaration of `RTCConfiguration` to properly resolve imports.
+namespace margelo::nitro::webrtc { struct RTCConfiguration; }
+// Forward declaration of `RTCSessionDescriptionInit` to properly resolve imports.
+namespace margelo::nitro::webrtc { struct RTCSessionDescriptionInit; }
+// Forward declaration of `RTCIceCandidateInit` to properly resolve imports.
+namespace margelo::nitro::webrtc { struct RTCIceCandidateInit; }
+// Forward declaration of `HybridRTCRtpTransceiverSpec` to properly resolve imports.
+namespace margelo::nitro::webrtc { class HybridRTCRtpTransceiverSpec; }
+// Forward declaration of `HybridMediaStreamTrackSpec` to properly resolve imports.
+namespace margelo::nitro::webrtc { class HybridMediaStreamTrackSpec; }
+// Forward declaration of `RTCRtpTransceiverInit` to properly resolve imports.
+namespace margelo::nitro::webrtc { struct RTCRtpTransceiverInit; }
+
+#include "RTCPeerConnectionState.hpp"
+#include "RTCIceGatheringState.hpp"
+#include <string>
+#include "Event.hpp"
+#include <functional>
+#include <optional>
+#include "RTCPeerConnectionIceEvent.hpp"
+#include "RTCTrackEvent.hpp"
+#include "RTCConfiguration.hpp"
+#include <NitroModules/Promise.hpp>
+#include "RTCSessionDescriptionInit.hpp"
+#include <NitroModules/Null.hpp>
+#include "RTCIceCandidateInit.hpp"
+#include <variant>
+#include <memory>
+#include "HybridRTCRtpTransceiverSpec.hpp"
+#include "HybridMediaStreamTrackSpec.hpp"
+#include "RTCRtpTransceiverInit.hpp"
+#include <vector>
+
+namespace margelo::nitro::webrtc {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `RTCPeerConnection`
+   * Inherit this class to create instances of `HybridRTCPeerConnectionSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridRTCPeerConnection: public HybridRTCPeerConnectionSpec {
+   * public:
+   *   HybridRTCPeerConnection(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridRTCPeerConnectionSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridRTCPeerConnectionSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridRTCPeerConnectionSpec() override = default;
+
+    public:
+      // Properties
+      virtual RTCPeerConnectionState getConnectionState() = 0;
+      virtual RTCIceGatheringState getIceGatheringState() = 0;
+      virtual std::string getLocalDescription() = 0;
+      virtual std::string getRemoteDescription() = 0;
+      virtual std::optional<std::function<void(const Event& /* event */)>> getOnconnectionstatechange() = 0;
+      virtual void setOnconnectionstatechange(const std::optional<std::function<void(const Event& /* event */)>>& onconnectionstatechange) = 0;
+      virtual std::optional<std::function<void(const Event& /* event */)>> getOnicegatheringstatechange() = 0;
+      virtual void setOnicegatheringstatechange(const std::optional<std::function<void(const Event& /* event */)>>& onicegatheringstatechange) = 0;
+      virtual std::optional<std::function<void(const RTCPeerConnectionIceEvent& /* event */)>> getOnicecandidate() = 0;
+      virtual void setOnicecandidate(const std::optional<std::function<void(const RTCPeerConnectionIceEvent& /* event */)>>& onicecandidate) = 0;
+      virtual std::optional<std::function<void(const RTCTrackEvent& /* event */)>> getOntrack() = 0;
+      virtual void setOntrack(const std::optional<std::function<void(const RTCTrackEvent& /* event */)>>& ontrack) = 0;
+
+    public:
+      // Methods
+      virtual void setConfiguration(const std::optional<RTCConfiguration>& config) = 0;
+      virtual void close() = 0;
+      virtual std::shared_ptr<Promise<void>> setLocalDescription(const std::optional<RTCSessionDescriptionInit>& description) = 0;
+      virtual std::shared_ptr<Promise<void>> setRemoteDescription(const RTCSessionDescriptionInit& description) = 0;
+      virtual std::shared_ptr<Promise<void>> addIceCandidate(const std::optional<std::variant<nitro::NullType, RTCIceCandidateInit>>& candidate) = 0;
+      virtual std::shared_ptr<HybridRTCRtpTransceiverSpec> addTransceiver(const std::variant<std::shared_ptr<HybridMediaStreamTrackSpec>, std::string>& trackOrKind, const std::optional<RTCRtpTransceiverInit>& init) = 0;
+      virtual std::vector<std::shared_ptr<HybridRTCRtpTransceiverSpec>> getTransceivers() = 0;
+      virtual std::shared_ptr<Promise<RTCSessionDescriptionInit>> createOffer() = 0;
+      virtual std::shared_ptr<Promise<RTCSessionDescriptionInit>> createAnswer() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "RTCPeerConnection";
+  };
+
+} // namespace margelo::nitro::webrtc

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

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

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

@@ -0,0 +1,66 @@
+///
+/// HybridRTCRtpReceiverSpec.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 `HybridMediaStreamTrackSpec` to properly resolve imports.
+namespace margelo::nitro::webrtc { class HybridMediaStreamTrackSpec; }
+
+#include <NitroModules/Null.hpp>
+#include <memory>
+#include "HybridMediaStreamTrackSpec.hpp"
+#include <variant>
+
+namespace margelo::nitro::webrtc {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `RTCRtpReceiver`
+   * Inherit this class to create instances of `HybridRTCRtpReceiverSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridRTCRtpReceiver: public HybridRTCRtpReceiverSpec {
+   * public:
+   *   HybridRTCRtpReceiver(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridRTCRtpReceiverSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridRTCRtpReceiverSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridRTCRtpReceiverSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::variant<nitro::NullType, std::shared_ptr<HybridMediaStreamTrackSpec>> getTrack() = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "RTCRtpReceiver";
+  };
+
+} // namespace margelo::nitro::webrtc

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

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

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

@@ -0,0 +1,66 @@
+///
+/// HybridRTCRtpSenderSpec.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 `HybridMediaStreamTrackSpec` to properly resolve imports.
+namespace margelo::nitro::webrtc { class HybridMediaStreamTrackSpec; }
+
+#include <NitroModules/Null.hpp>
+#include <memory>
+#include "HybridMediaStreamTrackSpec.hpp"
+#include <variant>
+
+namespace margelo::nitro::webrtc {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `RTCRtpSender`
+   * Inherit this class to create instances of `HybridRTCRtpSenderSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridRTCRtpSender: public HybridRTCRtpSenderSpec {
+   * public:
+   *   HybridRTCRtpSender(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridRTCRtpSenderSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridRTCRtpSenderSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridRTCRtpSenderSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::variant<nitro::NullType, std::shared_ptr<HybridMediaStreamTrackSpec>> getTrack() = 0;
+
+    public:
+      // Methods
+      
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "RTCRtpSender";
+  };
+
+} // namespace margelo::nitro::webrtc

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

@@ -0,0 +1,24 @@
+///
+/// HybridRTCRtpTransceiverSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridRTCRtpTransceiverSpec.hpp"
+
+namespace margelo::nitro::webrtc {
+
+  void HybridRTCRtpTransceiverSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("mid", &HybridRTCRtpTransceiverSpec::getMid);
+      prototype.registerHybridGetter("direction", &HybridRTCRtpTransceiverSpec::getDirection);
+      prototype.registerHybridGetter("sender", &HybridRTCRtpTransceiverSpec::getSender);
+      prototype.registerHybridGetter("receiver", &HybridRTCRtpTransceiverSpec::getReceiver);
+    });
+  }
+
+} // namespace margelo::nitro::webrtc