react-native-nitro-net 0.1.5 → 0.3.0

package/nitrogen/generated/android/c++/JHybridHttpParserSpec.cpp

@@ -0,0 +1,54 @@
+///
+/// JHybridHttpParserSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridHttpParserSpec.hpp"
+
+
+
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+
+namespace margelo::nitro::net {
+
+  jni::local_ref<JHybridHttpParserSpec::jhybriddata> JHybridHttpParserSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridHttpParserSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridHttpParserSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridHttpParserSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridHttpParserSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridHttpParserSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::string JHybridHttpParserSpec::feed(const std::shared_ptr<ArrayBuffer>& data) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<JArrayBuffer::javaobject> /* data */)>("feed");
+    auto __result = method(_javaPart, JArrayBuffer::wrap(data));
+    return __result->toStdString();
+  }
+
+} // namespace margelo::nitro::net

package/nitrogen/generated/android/c++/JHybridHttpParserSpec.hpp

@@ -0,0 +1,65 @@
+///
+/// HybridHttpParserSpec.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 <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridHttpParserSpec.hpp"
+
+
+
+
+namespace margelo::nitro::net {
+
+  using namespace facebook;
+
+  class JHybridHttpParserSpec: public jni::HybridClass<JHybridHttpParserSpec, JHybridObject>,
+                               public virtual HybridHttpParserSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/net/HybridHttpParserSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridHttpParserSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridHttpParserSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridHttpParserSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridHttpParserSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::string feed(const std::shared_ptr<ArrayBuffer>& data) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridHttpParserSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::net

package/nitrogen/generated/android/c++/JHybridNetDriverSpec.cpp

@@ -11,6 +11,8 @@
 namespace margelo::nitro::net { class HybridNetSocketDriverSpec; }
 // Forward declaration of `HybridNetServerDriverSpec` to properly resolve imports.
 namespace margelo::nitro::net { class HybridNetServerDriverSpec; }
+// Forward declaration of `HybridHttpParserSpec` to properly resolve imports.
+namespace margelo::nitro::net { class HybridHttpParserSpec; }
 // Forward declaration of `NetConfig` to properly resolve imports.
 namespace margelo::nitro::net { struct NetConfig; }
 
@@ -19,8 +21,12 @@ namespace margelo::nitro::net { struct NetConfig; }
 #include "JHybridNetSocketDriverSpec.hpp"
 #include "HybridNetServerDriverSpec.hpp"
 #include "JHybridNetServerDriverSpec.hpp"
-#include <string>
+#include "HybridHttpParserSpec.hpp"
+#include "JHybridHttpParserSpec.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
 #include <optional>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <string>
 #include "NetConfig.hpp"
 #include "JNetConfig.hpp"
 
@@ -66,6 +72,46 @@ namespace margelo::nitro::net {
     auto __result = method(_javaPart);
     return __result->cthis()->shared_cast<JHybridNetServerDriverSpec>();
   }
+  std::shared_ptr<HybridHttpParserSpec> JHybridNetDriverSpec::createHttpParser(double mode) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridHttpParserSpec::javaobject>(double /* mode */)>("createHttpParser");
+    auto __result = method(_javaPart, mode);
+    return __result->cthis()->shared_cast<JHybridHttpParserSpec>();
+  }
+  double JHybridNetDriverSpec::createSecureContext(const std::string& cert, const std::string& key, const std::optional<std::string>& passphrase) {
+    static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<jni::JString> /* cert */, jni::alias_ref<jni::JString> /* key */, jni::alias_ref<jni::JString> /* passphrase */)>("createSecureContext");
+    auto __result = method(_javaPart, jni::make_jstring(cert), jni::make_jstring(key), passphrase.has_value() ? jni::make_jstring(passphrase.value()) : nullptr);
+    return __result;
+  }
+  double JHybridNetDriverSpec::createEmptySecureContext() {
+    static const auto method = javaClassStatic()->getMethod<double()>("createEmptySecureContext");
+    auto __result = method(_javaPart);
+    return __result;
+  }
+  void JHybridNetDriverSpec::addCACertToSecureContext(double scId, const std::string& ca) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* scId */, jni::alias_ref<jni::JString> /* ca */)>("addCACertToSecureContext");
+    method(_javaPart, scId, jni::make_jstring(ca));
+  }
+  void JHybridNetDriverSpec::addContextToSecureContext(double scId, const std::string& hostname, const std::string& cert, const std::string& key, const std::optional<std::string>& passphrase) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* scId */, jni::alias_ref<jni::JString> /* hostname */, jni::alias_ref<jni::JString> /* cert */, jni::alias_ref<jni::JString> /* key */, jni::alias_ref<jni::JString> /* passphrase */)>("addContextToSecureContext");
+    method(_javaPart, scId, jni::make_jstring(hostname), jni::make_jstring(cert), jni::make_jstring(key), passphrase.has_value() ? jni::make_jstring(passphrase.value()) : nullptr);
+  }
+  void JHybridNetDriverSpec::setPFXToSecureContext(double scId, const std::shared_ptr<ArrayBuffer>& pfx, const std::optional<std::string>& passphrase) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* scId */, jni::alias_ref<JArrayBuffer::javaobject> /* pfx */, jni::alias_ref<jni::JString> /* passphrase */)>("setPFXToSecureContext");
+    method(_javaPart, scId, JArrayBuffer::wrap(pfx), passphrase.has_value() ? jni::make_jstring(passphrase.value()) : nullptr);
+  }
+  void JHybridNetDriverSpec::setOCSPResponseToSecureContext(double scId, const std::shared_ptr<ArrayBuffer>& ocsp) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* scId */, jni::alias_ref<JArrayBuffer::javaobject> /* ocsp */)>("setOCSPResponseToSecureContext");
+    method(_javaPart, scId, JArrayBuffer::wrap(ocsp));
+  }
+  std::optional<std::shared_ptr<ArrayBuffer>> JHybridNetDriverSpec::getTicketKeys(double scId) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JArrayBuffer::javaobject>(double /* scId */)>("getTicketKeys");
+    auto __result = method(_javaPart, scId);
+    return __result != nullptr ? std::make_optional(__result->cthis()->getArrayBuffer()) : std::nullopt;
+  }
+  void JHybridNetDriverSpec::setTicketKeys(double scId, const std::shared_ptr<ArrayBuffer>& keys) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* scId */, jni::alias_ref<JArrayBuffer::javaobject> /* keys */)>("setTicketKeys");
+    method(_javaPart, scId, JArrayBuffer::wrap(keys));
+  }
   void JHybridNetDriverSpec::initWithConfig(const NetConfig& config) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JNetConfig> /* config */)>("initWithConfig");
     method(_javaPart, JNetConfig::fromCpp(config));

package/nitrogen/generated/android/c++/JHybridNetDriverSpec.hpp

@@ -56,6 +56,15 @@ namespace margelo::nitro::net {
     // Methods
     std::shared_ptr<HybridNetSocketDriverSpec> createSocket(const std::optional<std::string>& id) override;
     std::shared_ptr<HybridNetServerDriverSpec> createServer() override;
+    std::shared_ptr<HybridHttpParserSpec> createHttpParser(double mode) override;
+    double createSecureContext(const std::string& cert, const std::string& key, const std::optional<std::string>& passphrase) override;
+    double createEmptySecureContext() override;
+    void addCACertToSecureContext(double scId, const std::string& ca) override;
+    void addContextToSecureContext(double scId, const std::string& hostname, const std::string& cert, const std::string& key, const std::optional<std::string>& passphrase) override;
+    void setPFXToSecureContext(double scId, const std::shared_ptr<ArrayBuffer>& pfx, const std::optional<std::string>& passphrase) override;
+    void setOCSPResponseToSecureContext(double scId, const std::shared_ptr<ArrayBuffer>& ocsp) override;
+    std::optional<std::shared_ptr<ArrayBuffer>> getTicketKeys(double scId) override;
+    void setTicketKeys(double scId, const std::shared_ptr<ArrayBuffer>& keys) override;
     void initWithConfig(const NetConfig& config) override;
 
   private:

package/nitrogen/generated/android/c++/JHybridNetServerDriverSpec.cpp

@@ -78,10 +78,18 @@ namespace margelo::nitro::net {
     static const auto method = javaClassStatic()->getMethod<void(double /* port */, jni::alias_ref<jni::JDouble> /* backlog */, jni::alias_ref<jni::JBoolean> /* ipv6Only */, jni::alias_ref<jni::JBoolean> /* reusePort */)>("listen");
     method(_javaPart, port, backlog.has_value() ? jni::JDouble::valueOf(backlog.value()) : nullptr, ipv6Only.has_value() ? jni::JBoolean::valueOf(ipv6Only.value()) : nullptr, reusePort.has_value() ? jni::JBoolean::valueOf(reusePort.value()) : nullptr);
   }
+  void JHybridNetServerDriverSpec::listenTLS(double port, double secureContextId, std::optional<double> backlog, std::optional<bool> ipv6Only, std::optional<bool> reusePort) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* port */, double /* secureContextId */, jni::alias_ref<jni::JDouble> /* backlog */, jni::alias_ref<jni::JBoolean> /* ipv6Only */, jni::alias_ref<jni::JBoolean> /* reusePort */)>("listenTLS");
+    method(_javaPart, port, secureContextId, backlog.has_value() ? jni::JDouble::valueOf(backlog.value()) : nullptr, ipv6Only.has_value() ? jni::JBoolean::valueOf(ipv6Only.value()) : nullptr, reusePort.has_value() ? jni::JBoolean::valueOf(reusePort.value()) : nullptr);
+  }
   void JHybridNetServerDriverSpec::listenUnix(const std::string& path, std::optional<double> backlog) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* path */, jni::alias_ref<jni::JDouble> /* backlog */)>("listenUnix");
     method(_javaPart, jni::make_jstring(path), backlog.has_value() ? jni::JDouble::valueOf(backlog.value()) : nullptr);
   }
+  void JHybridNetServerDriverSpec::listenTLSUnix(const std::string& path, double secureContextId, std::optional<double> backlog) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* path */, double /* secureContextId */, jni::alias_ref<jni::JDouble> /* backlog */)>("listenTLSUnix");
+    method(_javaPart, jni::make_jstring(path), secureContextId, backlog.has_value() ? jni::JDouble::valueOf(backlog.value()) : nullptr);
+  }
   void JHybridNetServerDriverSpec::listenHandle(double fd, std::optional<double> backlog) {
     static const auto method = javaClassStatic()->getMethod<void(double /* fd */, jni::alias_ref<jni::JDouble> /* backlog */)>("listenHandle");
     method(_javaPart, fd, backlog.has_value() ? jni::JDouble::valueOf(backlog.value()) : nullptr);

package/nitrogen/generated/android/c++/JHybridNetServerDriverSpec.hpp

@@ -58,7 +58,9 @@ namespace margelo::nitro::net {
   public:
     // Methods
     void listen(double port, std::optional<double> backlog, std::optional<bool> ipv6Only, std::optional<bool> reusePort) override;
+    void listenTLS(double port, double secureContextId, std::optional<double> backlog, std::optional<bool> ipv6Only, std::optional<bool> reusePort) override;
     void listenUnix(const std::string& path, std::optional<double> backlog) override;
+    void listenTLSUnix(const std::string& path, double secureContextId, std::optional<double> backlog) override;
     void listenHandle(double fd, std::optional<double> backlog) override;
     std::string getLocalAddress() override;
     void close() override;

package/nitrogen/generated/android/c++/JHybridNetSocketDriverSpec.cpp

@@ -15,6 +15,7 @@
 #include <NitroModules/JNICallable.hpp>
 #include <NitroModules/JArrayBuffer.hpp>
 #include <string>
+#include <optional>
 
 namespace margelo::nitro::net {
 
@@ -73,10 +74,75 @@ namespace margelo::nitro::net {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* host */, double /* port */)>("connect");
     method(_javaPart, jni::make_jstring(host), port);
   }
+  void JHybridNetSocketDriverSpec::connectTLS(const std::string& host, double port, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* host */, double /* port */, jni::alias_ref<jni::JString> /* serverName */, jni::alias_ref<jni::JBoolean> /* rejectUnauthorized */)>("connectTLS");
+    method(_javaPart, jni::make_jstring(host), port, serverName.has_value() ? jni::make_jstring(serverName.value()) : nullptr, rejectUnauthorized.has_value() ? jni::JBoolean::valueOf(rejectUnauthorized.value()) : nullptr);
+  }
+  void JHybridNetSocketDriverSpec::connectTLSWithContext(const std::string& host, double port, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized, std::optional<double> secureContextId) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* host */, double /* port */, jni::alias_ref<jni::JString> /* serverName */, jni::alias_ref<jni::JBoolean> /* rejectUnauthorized */, jni::alias_ref<jni::JDouble> /* secureContextId */)>("connectTLSWithContext");
+    method(_javaPart, jni::make_jstring(host), port, serverName.has_value() ? jni::make_jstring(serverName.value()) : nullptr, rejectUnauthorized.has_value() ? jni::JBoolean::valueOf(rejectUnauthorized.value()) : nullptr, secureContextId.has_value() ? jni::JDouble::valueOf(secureContextId.value()) : nullptr);
+  }
+  std::optional<std::string> JHybridNetSocketDriverSpec::getAuthorizationError() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getAuthorizationError");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  std::optional<std::string> JHybridNetSocketDriverSpec::getProtocol() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getProtocol");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  std::optional<std::string> JHybridNetSocketDriverSpec::getCipher() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getCipher");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  std::optional<std::string> JHybridNetSocketDriverSpec::getALPN() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getALPN");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  std::optional<std::string> JHybridNetSocketDriverSpec::getPeerCertificateJSON() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getPeerCertificateJSON");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  std::optional<std::string> JHybridNetSocketDriverSpec::getEphemeralKeyInfo() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getEphemeralKeyInfo");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  std::optional<std::string> JHybridNetSocketDriverSpec::getSharedSigalgs() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getSharedSigalgs");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->toStdString()) : std::nullopt;
+  }
+  bool JHybridNetSocketDriverSpec::isSessionReused() {
+    static const auto method = javaClassStatic()->getMethod<jboolean()>("isSessionReused");
+    auto __result = method(_javaPart);
+    return static_cast<bool>(__result);
+  }
+  std::optional<std::shared_ptr<ArrayBuffer>> JHybridNetSocketDriverSpec::getSession() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JArrayBuffer::javaobject>()>("getSession");
+    auto __result = method(_javaPart);
+    return __result != nullptr ? std::make_optional(__result->cthis()->getArrayBuffer()) : std::nullopt;
+  }
+  void JHybridNetSocketDriverSpec::setSession(const std::shared_ptr<ArrayBuffer>& session) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JArrayBuffer::javaobject> /* session */)>("setSession");
+    method(_javaPart, JArrayBuffer::wrap(session));
+  }
   void JHybridNetSocketDriverSpec::connectUnix(const std::string& path) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* path */)>("connectUnix");
     method(_javaPart, jni::make_jstring(path));
   }
+  void JHybridNetSocketDriverSpec::connectUnixTLS(const std::string& path, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* path */, jni::alias_ref<jni::JString> /* serverName */, jni::alias_ref<jni::JBoolean> /* rejectUnauthorized */)>("connectUnixTLS");
+    method(_javaPart, jni::make_jstring(path), serverName.has_value() ? jni::make_jstring(serverName.value()) : nullptr, rejectUnauthorized.has_value() ? jni::JBoolean::valueOf(rejectUnauthorized.value()) : nullptr);
+  }
+  void JHybridNetSocketDriverSpec::connectUnixTLSWithContext(const std::string& path, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized, std::optional<double> secureContextId) {
+    static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* path */, jni::alias_ref<jni::JString> /* serverName */, jni::alias_ref<jni::JBoolean> /* rejectUnauthorized */, jni::alias_ref<jni::JDouble> /* secureContextId */)>("connectUnixTLSWithContext");
+    method(_javaPart, jni::make_jstring(path), serverName.has_value() ? jni::make_jstring(serverName.value()) : nullptr, rejectUnauthorized.has_value() ? jni::JBoolean::valueOf(rejectUnauthorized.value()) : nullptr, secureContextId.has_value() ? jni::JDouble::valueOf(secureContextId.value()) : nullptr);
+  }
   void JHybridNetSocketDriverSpec::write(const std::shared_ptr<ArrayBuffer>& data) {
     static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JArrayBuffer::javaobject> /* data */)>("write");
     method(_javaPart, JArrayBuffer::wrap(data));
@@ -105,6 +171,19 @@ namespace margelo::nitro::net {
     static const auto method = javaClassStatic()->getMethod<void()>("resetAndDestroy");
     method(_javaPart);
   }
+  void JHybridNetSocketDriverSpec::enableKeylog() {
+    static const auto method = javaClassStatic()->getMethod<void()>("enableKeylog");
+    method(_javaPart);
+  }
+  void JHybridNetSocketDriverSpec::enableTrace() {
+    static const auto method = javaClassStatic()->getMethod<void()>("enableTrace");
+    method(_javaPart);
+  }
+  std::optional<std::shared_ptr<ArrayBuffer>> JHybridNetSocketDriverSpec::exportKeyingMaterial(double length, const std::string& label, const std::optional<std::shared_ptr<ArrayBuffer>>& context) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JArrayBuffer::javaobject>(double /* length */, jni::alias_ref<jni::JString> /* label */, jni::alias_ref<JArrayBuffer::javaobject> /* context */)>("exportKeyingMaterial");
+    auto __result = method(_javaPart, length, jni::make_jstring(label), context.has_value() ? JArrayBuffer::wrap(context.value()) : nullptr);
+    return __result != nullptr ? std::make_optional(__result->cthis()->getArrayBuffer()) : std::nullopt;
+  }
   void JHybridNetSocketDriverSpec::setNoDelay(bool enable) {
     static const auto method = javaClassStatic()->getMethod<void(jboolean /* enable */)>("setNoDelay");
     method(_javaPart, enable);

package/nitrogen/generated/android/c++/JHybridNetSocketDriverSpec.hpp

@@ -57,7 +57,21 @@ namespace margelo::nitro::net {
   public:
     // Methods
     void connect(const std::string& host, double port) override;
+    void connectTLS(const std::string& host, double port, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized) override;
+    void connectTLSWithContext(const std::string& host, double port, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized, std::optional<double> secureContextId) override;
+    std::optional<std::string> getAuthorizationError() override;
+    std::optional<std::string> getProtocol() override;
+    std::optional<std::string> getCipher() override;
+    std::optional<std::string> getALPN() override;
+    std::optional<std::string> getPeerCertificateJSON() override;
+    std::optional<std::string> getEphemeralKeyInfo() override;
+    std::optional<std::string> getSharedSigalgs() override;
+    bool isSessionReused() override;
+    std::optional<std::shared_ptr<ArrayBuffer>> getSession() override;
+    void setSession(const std::shared_ptr<ArrayBuffer>& session) override;
     void connectUnix(const std::string& path) override;
+    void connectUnixTLS(const std::string& path, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized) override;
+    void connectUnixTLSWithContext(const std::string& path, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized, std::optional<double> secureContextId) override;
     void write(const std::shared_ptr<ArrayBuffer>& data) override;
     void pause() override;
     void resume() override;
@@ -65,6 +79,9 @@ namespace margelo::nitro::net {
     void setTimeout(double timeout) override;
     void destroy() override;
     void resetAndDestroy() override;
+    void enableKeylog() override;
+    void enableTrace() override;
+    std::optional<std::shared_ptr<ArrayBuffer>> exportKeyingMaterial(double length, const std::string& label, const std::optional<std::shared_ptr<ArrayBuffer>>& context) override;
     void setNoDelay(bool enable) override;
     void setKeepAlive(bool enable, double delay) override;
     std::string getLocalAddress() override;

package/nitrogen/generated/android/c++/JNetConfig.hpp

@@ -33,8 +33,11 @@ namespace margelo::nitro::net {
       static const auto clazz = javaClassStatic();
       static const auto fieldWorkerThreads = clazz->getField<jni::JDouble>("workerThreads");
       jni::local_ref<jni::JDouble> workerThreads = this->getFieldValue(fieldWorkerThreads);
+      static const auto fieldDebug = clazz->getField<jni::JBoolean>("debug");
+      jni::local_ref<jni::JBoolean> debug = this->getFieldValue(fieldDebug);
       return NetConfig(
-        workerThreads != nullptr ? std::make_optional(workerThreads->value()) : std::nullopt
+        workerThreads != nullptr ? std::make_optional(workerThreads->value()) : std::nullopt,
+        debug != nullptr ? std::make_optional(static_cast<bool>(debug->value())) : std::nullopt
       );
     }
 
@@ -44,12 +47,13 @@ namespace margelo::nitro::net {
      */
     [[maybe_unused]]
     static jni::local_ref<JNetConfig::javaobject> fromCpp(const NetConfig& value) {
-      using JSignature = JNetConfig(jni::alias_ref<jni::JDouble>);
+      using JSignature = JNetConfig(jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JBoolean>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
         clazz,
-        value.workerThreads.has_value() ? jni::JDouble::valueOf(value.workerThreads.value()) : nullptr
+        value.workerThreads.has_value() ? jni::JDouble::valueOf(value.workerThreads.value()) : nullptr,
+        value.debug.has_value() ? jni::JBoolean::valueOf(value.debug.value()) : nullptr
       );
     }
   };

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/HybridHttpParserSpec.kt

@@ -0,0 +1,58 @@
+///
+/// HybridHttpParserSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.net
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.ArrayBuffer
+import com.margelo.nitro.core.HybridObject
+
+/**
+ * A Kotlin class representing the HttpParser HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of HttpParser.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridHttpParserSpec: HybridObject() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Default implementation of `HybridObject.toString()`
+  override fun toString(): String {
+    return "[HybridObject HttpParser]"
+  }
+
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun feed(data: ArrayBuffer): String
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    protected const val TAG = "HybridHttpParserSpec"
+  }
+}

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/HybridNetDriverSpec.kt

@@ -10,6 +10,7 @@ package com.margelo.nitro.net
 import androidx.annotation.Keep
 import com.facebook.jni.HybridData
 import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.ArrayBuffer
 import com.margelo.nitro.core.HybridObject
 
 /**
@@ -53,6 +54,42 @@ abstract class HybridNetDriverSpec: HybridObject() {
   @Keep
   abstract fun createServer(): HybridNetServerDriverSpec
   
+  @DoNotStrip
+  @Keep
+  abstract fun createHttpParser(mode: Double): HybridHttpParserSpec
+  
+  @DoNotStrip
+  @Keep
+  abstract fun createSecureContext(cert: String, key: String, passphrase: String?): Double
+  
+  @DoNotStrip
+  @Keep
+  abstract fun createEmptySecureContext(): Double
+  
+  @DoNotStrip
+  @Keep
+  abstract fun addCACertToSecureContext(scId: Double, ca: String): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun addContextToSecureContext(scId: Double, hostname: String, cert: String, key: String, passphrase: String?): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setPFXToSecureContext(scId: Double, pfx: ArrayBuffer, passphrase: String?): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setOCSPResponseToSecureContext(scId: Double, ocsp: ArrayBuffer): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getTicketKeys(scId: Double): ArrayBuffer?
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setTicketKeys(scId: Double, keys: ArrayBuffer): Unit
+  
   @DoNotStrip
   @Keep
   abstract fun initWithConfig(config: NetConfig): Unit

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/HybridNetServerDriverSpec.kt

@@ -68,10 +68,18 @@ abstract class HybridNetServerDriverSpec: HybridObject() {
   @Keep
   abstract fun listen(port: Double, backlog: Double?, ipv6Only: Boolean?, reusePort: Boolean?): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun listenTLS(port: Double, secureContextId: Double, backlog: Double?, ipv6Only: Boolean?, reusePort: Boolean?): Unit
+  
   @DoNotStrip
   @Keep
   abstract fun listenUnix(path: String, backlog: Double?): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun listenTLSUnix(path: String, secureContextId: Double, backlog: Double?): Unit
+  
   @DoNotStrip
   @Keep
   abstract fun listenHandle(fd: Double, backlog: Double?): Unit

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/HybridNetSocketDriverSpec.kt

@@ -66,10 +66,66 @@ abstract class HybridNetSocketDriverSpec: HybridObject() {
   @Keep
   abstract fun connect(host: String, port: Double): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun connectTLS(host: String, port: Double, serverName: String?, rejectUnauthorized: Boolean?): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun connectTLSWithContext(host: String, port: Double, serverName: String?, rejectUnauthorized: Boolean?, secureContextId: Double?): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getAuthorizationError(): String?
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getProtocol(): String?
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getCipher(): String?
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getALPN(): String?
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getPeerCertificateJSON(): String?
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getEphemeralKeyInfo(): String?
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getSharedSigalgs(): String?
+  
+  @DoNotStrip
+  @Keep
+  abstract fun isSessionReused(): Boolean
+  
+  @DoNotStrip
+  @Keep
+  abstract fun getSession(): ArrayBuffer?
+  
+  @DoNotStrip
+  @Keep
+  abstract fun setSession(session: ArrayBuffer): Unit
+  
   @DoNotStrip
   @Keep
   abstract fun connectUnix(path: String): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun connectUnixTLS(path: String, serverName: String?, rejectUnauthorized: Boolean?): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun connectUnixTLSWithContext(path: String, serverName: String?, rejectUnauthorized: Boolean?, secureContextId: Double?): Unit
+  
   @DoNotStrip
   @Keep
   abstract fun write(data: ArrayBuffer): Unit
@@ -98,6 +154,18 @@ abstract class HybridNetSocketDriverSpec: HybridObject() {
   @Keep
   abstract fun resetAndDestroy(): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun enableKeylog(): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun enableTrace(): Unit
+  
+  @DoNotStrip
+  @Keep
+  abstract fun exportKeyingMaterial(length: Double, label: String, context: ArrayBuffer?): ArrayBuffer?
+  
   @DoNotStrip
   @Keep
   abstract fun setNoDelay(enable: Boolean): Unit

package/nitrogen/generated/android/kotlin/com/margelo/nitro/net/NetConfig.kt

@@ -19,7 +19,10 @@ import com.facebook.proguard.annotations.DoNotStrip
 data class NetConfig(
   @DoNotStrip
   @Keep
-  val workerThreads: Double?
+  val workerThreads: Double?,
+  @DoNotStrip
+  @Keep
+  val debug: Boolean?
 ) {
   /* primary constructor */
 
@@ -31,8 +34,8 @@ data class NetConfig(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(workerThreads: Double?): NetConfig {
-      return NetConfig(workerThreads)
+    private fun fromCpp(workerThreads: Double?, debug: Boolean?): NetConfig {
+      return NetConfig(workerThreads, debug)
     }
   }
 }