react-native-nitro-net 0.1.5 → 0.3.0

package/nitrogen/generated/ios/swift/HybridNetSocketDriverSpec_cxx.swift

@@ -152,6 +152,223 @@ open class HybridNetSocketDriverSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func connectTLS(host: std.string, port: Double, serverName: bridge.std__optional_std__string_, rejectUnauthorized: bridge.std__optional_bool_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.connectTLS(host: String(host), port: port, serverName: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(serverName) {
+          let __unwrapped = bridge.get_std__optional_std__string_(serverName)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }(), rejectUnauthorized: { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(rejectUnauthorized) {
+          let __unwrapped = bridge.get_std__optional_bool_(rejectUnauthorized)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func connectTLSWithContext(host: std.string, port: Double, serverName: bridge.std__optional_std__string_, rejectUnauthorized: bridge.std__optional_bool_, secureContextId: bridge.std__optional_double_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.connectTLSWithContext(host: String(host), port: port, serverName: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(serverName) {
+          let __unwrapped = bridge.get_std__optional_std__string_(serverName)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }(), rejectUnauthorized: { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(rejectUnauthorized) {
+          let __unwrapped = bridge.get_std__optional_bool_(rejectUnauthorized)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }(), secureContextId: secureContextId.value)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getAuthorizationError() -> bridge.Result_std__optional_std__string__ {
+    do {
+      let __result = try self.__implementation.getAuthorizationError()
+      let __resultCpp = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_std__string__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_std__string__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getProtocol() -> bridge.Result_std__optional_std__string__ {
+    do {
+      let __result = try self.__implementation.getProtocol()
+      let __resultCpp = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_std__string__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_std__string__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getCipher() -> bridge.Result_std__optional_std__string__ {
+    do {
+      let __result = try self.__implementation.getCipher()
+      let __resultCpp = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_std__string__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_std__string__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getALPN() -> bridge.Result_std__optional_std__string__ {
+    do {
+      let __result = try self.__implementation.getALPN()
+      let __resultCpp = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_std__string__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_std__string__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getPeerCertificateJSON() -> bridge.Result_std__optional_std__string__ {
+    do {
+      let __result = try self.__implementation.getPeerCertificateJSON()
+      let __resultCpp = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_std__string__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_std__string__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getEphemeralKeyInfo() -> bridge.Result_std__optional_std__string__ {
+    do {
+      let __result = try self.__implementation.getEphemeralKeyInfo()
+      let __resultCpp = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_std__string__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_std__string__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getSharedSigalgs() -> bridge.Result_std__optional_std__string__ {
+    do {
+      let __result = try self.__implementation.getSharedSigalgs()
+      let __resultCpp = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_std__string__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_std__string__(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func isSessionReused() -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.isSessionReused()
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getSession() -> bridge.Result_std__optional_std__shared_ptr_ArrayBuffer___ {
+    do {
+      let __result = try self.__implementation.getSession()
+      let __resultCpp = { () -> bridge.std__optional_std__shared_ptr_ArrayBuffer__ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_std__shared_ptr_ArrayBuffer__(__unwrappedValue.getArrayBuffer())
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_std__shared_ptr_ArrayBuffer___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_std__shared_ptr_ArrayBuffer___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func setSession(session: ArrayBuffer) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setSession(session: session)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func connectUnix(path: std.string) -> bridge.Result_void_ {
     do {
@@ -163,6 +380,56 @@ open class HybridNetSocketDriverSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func connectUnixTLS(path: std.string, serverName: bridge.std__optional_std__string_, rejectUnauthorized: bridge.std__optional_bool_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.connectUnixTLS(path: String(path), serverName: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(serverName) {
+          let __unwrapped = bridge.get_std__optional_std__string_(serverName)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }(), rejectUnauthorized: { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(rejectUnauthorized) {
+          let __unwrapped = bridge.get_std__optional_bool_(rejectUnauthorized)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }())
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func connectUnixTLSWithContext(path: std.string, serverName: bridge.std__optional_std__string_, rejectUnauthorized: bridge.std__optional_bool_, secureContextId: bridge.std__optional_double_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.connectUnixTLSWithContext(path: String(path), serverName: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(serverName) {
+          let __unwrapped = bridge.get_std__optional_std__string_(serverName)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }(), rejectUnauthorized: { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(rejectUnauthorized) {
+          let __unwrapped = bridge.get_std__optional_bool_(rejectUnauthorized)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }(), secureContextId: secureContextId.value)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func write(data: ArrayBuffer) -> bridge.Result_void_ {
     do {
@@ -240,6 +507,53 @@ open class HybridNetSocketDriverSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func enableKeylog() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.enableKeylog()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func enableTrace() -> bridge.Result_void_ {
+    do {
+      try self.__implementation.enableTrace()
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func exportKeyingMaterial(length: Double, label: std.string, context: bridge.std__optional_std__shared_ptr_ArrayBuffer__) -> bridge.Result_std__optional_std__shared_ptr_ArrayBuffer___ {
+    do {
+      let __result = try self.__implementation.exportKeyingMaterial(length: length, label: String(label), context: { () -> ArrayBuffer? in
+        if bridge.has_value_std__optional_std__shared_ptr_ArrayBuffer__(context) {
+          let __unwrapped = bridge.get_std__optional_std__shared_ptr_ArrayBuffer__(context)
+          return ArrayBuffer(__unwrapped)
+        } else {
+          return nil
+        }
+      }())
+      let __resultCpp = { () -> bridge.std__optional_std__shared_ptr_ArrayBuffer__ in
+        if let __unwrappedValue = __result {
+          return bridge.create_std__optional_std__shared_ptr_ArrayBuffer__(__unwrappedValue.getArrayBuffer())
+        } else {
+          return .init()
+        }
+      }()
+      return bridge.create_Result_std__optional_std__shared_ptr_ArrayBuffer___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_std__shared_ptr_ArrayBuffer___(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func setNoDelay(enable: Bool) -> bridge.Result_void_ {
     do {

package/nitrogen/generated/ios/swift/NetConfig.swift

@@ -19,13 +19,19 @@ public extension NetConfig {
   /**
    * Create a new instance of `NetConfig`.
    */
-  init(workerThreads: Double?) {
+  init(workerThreads: Double?, debug: Bool?) {
     self.init({ () -> bridge.std__optional_double_ in
       if let __unwrappedValue = workerThreads {
         return bridge.create_std__optional_double_(__unwrappedValue)
       } else {
         return .init()
       }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = debug {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
     }())
   }
 
@@ -33,4 +39,16 @@ public extension NetConfig {
   var workerThreads: Double? {
     return self.__workerThreads.value
   }
+  
+  @inline(__always)
+  var debug: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__debug) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__debug)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
 }

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

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

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

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

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

@@ -16,6 +16,15 @@ namespace margelo::nitro::net {
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("createSocket", &HybridNetDriverSpec::createSocket);
       prototype.registerHybridMethod("createServer", &HybridNetDriverSpec::createServer);
+      prototype.registerHybridMethod("createHttpParser", &HybridNetDriverSpec::createHttpParser);
+      prototype.registerHybridMethod("createSecureContext", &HybridNetDriverSpec::createSecureContext);
+      prototype.registerHybridMethod("createEmptySecureContext", &HybridNetDriverSpec::createEmptySecureContext);
+      prototype.registerHybridMethod("addCACertToSecureContext", &HybridNetDriverSpec::addCACertToSecureContext);
+      prototype.registerHybridMethod("addContextToSecureContext", &HybridNetDriverSpec::addContextToSecureContext);
+      prototype.registerHybridMethod("setPFXToSecureContext", &HybridNetDriverSpec::setPFXToSecureContext);
+      prototype.registerHybridMethod("setOCSPResponseToSecureContext", &HybridNetDriverSpec::setOCSPResponseToSecureContext);
+      prototype.registerHybridMethod("getTicketKeys", &HybridNetDriverSpec::getTicketKeys);
+      prototype.registerHybridMethod("setTicketKeys", &HybridNetDriverSpec::setTicketKeys);
       prototype.registerHybridMethod("initWithConfig", &HybridNetDriverSpec::initWithConfig);
     });
   }

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

@@ -17,6 +17,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; }
 
@@ -25,6 +27,8 @@ namespace margelo::nitro::net { struct NetConfig; }
 #include <string>
 #include <optional>
 #include "HybridNetServerDriverSpec.hpp"
+#include "HybridHttpParserSpec.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
 #include "NetConfig.hpp"
 
 namespace margelo::nitro::net {
@@ -60,6 +64,15 @@ namespace margelo::nitro::net {
       // Methods
       virtual std::shared_ptr<HybridNetSocketDriverSpec> createSocket(const std::optional<std::string>& id) = 0;
       virtual std::shared_ptr<HybridNetServerDriverSpec> createServer() = 0;
+      virtual std::shared_ptr<HybridHttpParserSpec> createHttpParser(double mode) = 0;
+      virtual double createSecureContext(const std::string& cert, const std::string& key, const std::optional<std::string>& passphrase) = 0;
+      virtual double createEmptySecureContext() = 0;
+      virtual void addCACertToSecureContext(double scId, const std::string& ca) = 0;
+      virtual void addContextToSecureContext(double scId, const std::string& hostname, const std::string& cert, const std::string& key, const std::optional<std::string>& passphrase) = 0;
+      virtual void setPFXToSecureContext(double scId, const std::shared_ptr<ArrayBuffer>& pfx, const std::optional<std::string>& passphrase) = 0;
+      virtual void setOCSPResponseToSecureContext(double scId, const std::shared_ptr<ArrayBuffer>& ocsp) = 0;
+      virtual std::optional<std::shared_ptr<ArrayBuffer>> getTicketKeys(double scId) = 0;
+      virtual void setTicketKeys(double scId, const std::shared_ptr<ArrayBuffer>& keys) = 0;
       virtual void initWithConfig(const NetConfig& config) = 0;
 
     protected:

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

@@ -19,7 +19,9 @@ namespace margelo::nitro::net {
       prototype.registerHybridGetter("maxConnections", &HybridNetServerDriverSpec::getMaxConnections);
       prototype.registerHybridSetter("maxConnections", &HybridNetServerDriverSpec::setMaxConnections);
       prototype.registerHybridMethod("listen", &HybridNetServerDriverSpec::listen);
+      prototype.registerHybridMethod("listenTLS", &HybridNetServerDriverSpec::listenTLS);
       prototype.registerHybridMethod("listenUnix", &HybridNetServerDriverSpec::listenUnix);
+      prototype.registerHybridMethod("listenTLSUnix", &HybridNetServerDriverSpec::listenTLSUnix);
       prototype.registerHybridMethod("listenHandle", &HybridNetServerDriverSpec::listenHandle);
       prototype.registerHybridMethod("getLocalAddress", &HybridNetServerDriverSpec::getLocalAddress);
       prototype.registerHybridMethod("close", &HybridNetServerDriverSpec::close);

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

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

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

@@ -18,7 +18,21 @@ namespace margelo::nitro::net {
       prototype.registerHybridGetter("onEvent", &HybridNetSocketDriverSpec::getOnEvent);
       prototype.registerHybridSetter("onEvent", &HybridNetSocketDriverSpec::setOnEvent);
       prototype.registerHybridMethod("connect", &HybridNetSocketDriverSpec::connect);
+      prototype.registerHybridMethod("connectTLS", &HybridNetSocketDriverSpec::connectTLS);
+      prototype.registerHybridMethod("connectTLSWithContext", &HybridNetSocketDriverSpec::connectTLSWithContext);
+      prototype.registerHybridMethod("getAuthorizationError", &HybridNetSocketDriverSpec::getAuthorizationError);
+      prototype.registerHybridMethod("getProtocol", &HybridNetSocketDriverSpec::getProtocol);
+      prototype.registerHybridMethod("getCipher", &HybridNetSocketDriverSpec::getCipher);
+      prototype.registerHybridMethod("getALPN", &HybridNetSocketDriverSpec::getALPN);
+      prototype.registerHybridMethod("getPeerCertificateJSON", &HybridNetSocketDriverSpec::getPeerCertificateJSON);
+      prototype.registerHybridMethod("getEphemeralKeyInfo", &HybridNetSocketDriverSpec::getEphemeralKeyInfo);
+      prototype.registerHybridMethod("getSharedSigalgs", &HybridNetSocketDriverSpec::getSharedSigalgs);
+      prototype.registerHybridMethod("isSessionReused", &HybridNetSocketDriverSpec::isSessionReused);
+      prototype.registerHybridMethod("getSession", &HybridNetSocketDriverSpec::getSession);
+      prototype.registerHybridMethod("setSession", &HybridNetSocketDriverSpec::setSession);
       prototype.registerHybridMethod("connectUnix", &HybridNetSocketDriverSpec::connectUnix);
+      prototype.registerHybridMethod("connectUnixTLS", &HybridNetSocketDriverSpec::connectUnixTLS);
+      prototype.registerHybridMethod("connectUnixTLSWithContext", &HybridNetSocketDriverSpec::connectUnixTLSWithContext);
       prototype.registerHybridMethod("write", &HybridNetSocketDriverSpec::write);
       prototype.registerHybridMethod("pause", &HybridNetSocketDriverSpec::pause);
       prototype.registerHybridMethod("resume", &HybridNetSocketDriverSpec::resume);
@@ -26,6 +40,9 @@ namespace margelo::nitro::net {
       prototype.registerHybridMethod("setTimeout", &HybridNetSocketDriverSpec::setTimeout);
       prototype.registerHybridMethod("destroy", &HybridNetSocketDriverSpec::destroy);
       prototype.registerHybridMethod("resetAndDestroy", &HybridNetSocketDriverSpec::resetAndDestroy);
+      prototype.registerHybridMethod("enableKeylog", &HybridNetSocketDriverSpec::enableKeylog);
+      prototype.registerHybridMethod("enableTrace", &HybridNetSocketDriverSpec::enableTrace);
+      prototype.registerHybridMethod("exportKeyingMaterial", &HybridNetSocketDriverSpec::exportKeyingMaterial);
       prototype.registerHybridMethod("setNoDelay", &HybridNetSocketDriverSpec::setNoDelay);
       prototype.registerHybridMethod("setKeepAlive", &HybridNetSocketDriverSpec::setKeepAlive);
       prototype.registerHybridMethod("getLocalAddress", &HybridNetSocketDriverSpec::getLocalAddress);

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

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

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

@@ -40,10 +40,11 @@ namespace margelo::nitro::net {
   struct NetConfig final {
   public:
     std::optional<double> workerThreads     SWIFT_PRIVATE;
+    std::optional<bool> debug     SWIFT_PRIVATE;
 
   public:
     NetConfig() = default;
-    explicit NetConfig(std::optional<double> workerThreads): workerThreads(workerThreads) {}
+    explicit NetConfig(std::optional<double> workerThreads, std::optional<bool> debug): workerThreads(workerThreads), debug(debug) {}
 
   public:
     friend bool operator==(const NetConfig& lhs, const NetConfig& rhs) = default;
@@ -59,12 +60,14 @@ namespace margelo::nitro {
     static inline margelo::nitro::net::NetConfig fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::net::NetConfig(
-        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "workerThreads")))
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "workerThreads"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "debug")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::net::NetConfig& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "workerThreads"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.workerThreads));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "debug"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.debug));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -76,6 +79,7 @@ namespace margelo::nitro {
         return false;
       }
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "workerThreads")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "debug")))) return false;
       return true;
     }
   };