react-native-nitro-net 0.1.5 → 0.2.0

package/nitrogen/generated/ios/c++/HybridNetSocketDriverSpecSwift.hpp

@@ -19,6 +19,7 @@ namespace NitroModules { class ArrayBufferHolder; }
 #include <functional>
 #include <NitroModules/ArrayBufferHolder.hpp>
 #include <string>
+#include <optional>
 
 #include "RustCNet-Swift-Cxx-Umbrella.hpp"
 
@@ -79,12 +80,114 @@ namespace margelo::nitro::net {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void connectTLS(const std::string& host, double port, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized) override {
+      auto __result = _swiftPart.connectTLS(host, std::forward<decltype(port)>(port), serverName, rejectUnauthorized);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void connectTLSWithContext(const std::string& host, double port, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized, std::optional<double> secureContextId) override {
+      auto __result = _swiftPart.connectTLSWithContext(host, std::forward<decltype(port)>(port), serverName, rejectUnauthorized, secureContextId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::optional<std::string> getAuthorizationError() override {
+      auto __result = _swiftPart.getAuthorizationError();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::optional<std::string> getProtocol() override {
+      auto __result = _swiftPart.getProtocol();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::optional<std::string> getCipher() override {
+      auto __result = _swiftPart.getCipher();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::optional<std::string> getALPN() override {
+      auto __result = _swiftPart.getALPN();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::optional<std::string> getPeerCertificateJSON() override {
+      auto __result = _swiftPart.getPeerCertificateJSON();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::optional<std::string> getEphemeralKeyInfo() override {
+      auto __result = _swiftPart.getEphemeralKeyInfo();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::optional<std::string> getSharedSigalgs() override {
+      auto __result = _swiftPart.getSharedSigalgs();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline bool isSessionReused() override {
+      auto __result = _swiftPart.isSessionReused();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::optional<std::shared_ptr<ArrayBuffer>> getSession() override {
+      auto __result = _swiftPart.getSession();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void setSession(const std::shared_ptr<ArrayBuffer>& session) override {
+      auto __result = _swiftPart.setSession(ArrayBufferHolder(session));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void connectUnix(const std::string& path) override {
       auto __result = _swiftPart.connectUnix(path);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void connectUnixTLS(const std::string& path, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized) override {
+      auto __result = _swiftPart.connectUnixTLS(path, serverName, rejectUnauthorized);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void connectUnixTLSWithContext(const std::string& path, const std::optional<std::string>& serverName, std::optional<bool> rejectUnauthorized, std::optional<double> secureContextId) override {
+      auto __result = _swiftPart.connectUnixTLSWithContext(path, serverName, rejectUnauthorized, secureContextId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void write(const std::shared_ptr<ArrayBuffer>& data) override {
       auto __result = _swiftPart.write(ArrayBufferHolder(data));
       if (__result.hasError()) [[unlikely]] {
@@ -127,6 +230,12 @@ namespace margelo::nitro::net {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void enableKeylog() override {
+      auto __result = _swiftPart.enableKeylog();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void setNoDelay(bool enable) override {
       auto __result = _swiftPart.setNoDelay(std::forward<decltype(enable)>(enable));
       if (__result.hasError()) [[unlikely]] {

package/nitrogen/generated/ios/swift/HybridNetDriverSpec.swift

@@ -16,6 +16,14 @@ public protocol HybridNetDriverSpec_protocol: HybridObject {
   // Methods
   func createSocket(id: String?) throws -> (any HybridNetSocketDriverSpec)
   func createServer() throws -> (any HybridNetServerDriverSpec)
+  func createSecureContext(cert: String, key: String, passphrase: String?) throws -> Double
+  func createEmptySecureContext() throws -> Double
+  func addCACertToSecureContext(scId: Double, ca: String) throws -> Void
+  func addContextToSecureContext(scId: Double, hostname: String, cert: String, key: String, passphrase: String?) throws -> Void
+  func setPFXToSecureContext(scId: Double, pfx: ArrayBuffer, passphrase: String?) throws -> Void
+  func setOCSPResponseToSecureContext(scId: Double, ocsp: ArrayBuffer) throws -> Void
+  func getTicketKeys(scId: Double) throws -> ArrayBuffer?
+  func setTicketKeys(scId: Double, keys: ArrayBuffer) throws -> Void
   func initWithConfig(config: NetConfig) throws -> Void
 }
 

package/nitrogen/generated/ios/swift/HybridNetDriverSpec_cxx.swift

@@ -154,6 +154,124 @@ open class HybridNetDriverSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func createSecureContext(cert: std.string, key: std.string, passphrase: bridge.std__optional_std__string_) -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.createSecureContext(cert: String(cert), key: String(key), passphrase: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(passphrase) {
+          let __unwrapped = bridge.get_std__optional_std__string_(passphrase)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }())
+      let __resultCpp = __result
+      return bridge.create_Result_double_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_double_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func createEmptySecureContext() -> bridge.Result_double_ {
+    do {
+      let __result = try self.__implementation.createEmptySecureContext()
+      let __resultCpp = __result
+      return bridge.create_Result_double_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_double_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func addCACertToSecureContext(scId: Double, ca: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.addCACertToSecureContext(scId: scId, ca: String(ca))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func addContextToSecureContext(scId: Double, hostname: std.string, cert: std.string, key: std.string, passphrase: bridge.std__optional_std__string_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.addContextToSecureContext(scId: scId, hostname: String(hostname), cert: String(cert), key: String(key), passphrase: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(passphrase) {
+          let __unwrapped = bridge.get_std__optional_std__string_(passphrase)
+          return String(__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 setPFXToSecureContext(scId: Double, pfx: ArrayBuffer, passphrase: bridge.std__optional_std__string_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setPFXToSecureContext(scId: scId, pfx: pfx, passphrase: { () -> String? in
+        if bridge.has_value_std__optional_std__string_(passphrase) {
+          let __unwrapped = bridge.get_std__optional_std__string_(passphrase)
+          return String(__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 setOCSPResponseToSecureContext(scId: Double, ocsp: ArrayBuffer) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setOCSPResponseToSecureContext(scId: scId, ocsp: ocsp)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func getTicketKeys(scId: Double) -> bridge.Result_std__optional_std__shared_ptr_ArrayBuffer___ {
+    do {
+      let __result = try self.__implementation.getTicketKeys(scId: scId)
+      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 setTicketKeys(scId: Double, keys: ArrayBuffer) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setTicketKeys(scId: scId, keys: keys)
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func initWithConfig(config: NetConfig) -> bridge.Result_void_ {
     do {

package/nitrogen/generated/ios/swift/HybridNetServerDriverSpec.swift

@@ -16,6 +16,7 @@ public protocol HybridNetServerDriverSpec_protocol: HybridObject {
 
   // Methods
   func listen(port: Double, backlog: Double?, ipv6Only: Bool?, reusePort: Bool?) throws -> Void
+  func listenTLS(port: Double, secureContextId: Double, backlog: Double?, ipv6Only: Bool?, reusePort: Bool?) throws -> Void
   func listenUnix(path: String, backlog: Double?) throws -> Void
   func listenHandle(fd: Double, backlog: Double?) throws -> Void
   func getLocalAddress() throws -> String

package/nitrogen/generated/ios/swift/HybridNetServerDriverSpec_cxx.swift

@@ -170,6 +170,31 @@ open class HybridNetServerDriverSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func listenTLS(port: Double, secureContextId: Double, backlog: bridge.std__optional_double_, ipv6Only: bridge.std__optional_bool_, reusePort: bridge.std__optional_bool_) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.listenTLS(port: port, secureContextId: secureContextId, backlog: backlog.value, ipv6Only: { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(ipv6Only) {
+          let __unwrapped = bridge.get_std__optional_bool_(ipv6Only)
+          return __unwrapped
+        } else {
+          return nil
+        }
+      }(), reusePort: { () -> Bool? in
+        if bridge.has_value_std__optional_bool_(reusePort) {
+          let __unwrapped = bridge.get_std__optional_bool_(reusePort)
+          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 listenUnix(path: std.string, backlog: bridge.std__optional_double_) -> bridge.Result_void_ {
     do {

package/nitrogen/generated/ios/swift/HybridNetSocketDriverSpec.swift

@@ -16,7 +16,21 @@ public protocol HybridNetSocketDriverSpec_protocol: HybridObject {
 
   // Methods
   func connect(host: String, port: Double) throws -> Void
+  func connectTLS(host: String, port: Double, serverName: String?, rejectUnauthorized: Bool?) throws -> Void
+  func connectTLSWithContext(host: String, port: Double, serverName: String?, rejectUnauthorized: Bool?, secureContextId: Double?) throws -> Void
+  func getAuthorizationError() throws -> String?
+  func getProtocol() throws -> String?
+  func getCipher() throws -> String?
+  func getALPN() throws -> String?
+  func getPeerCertificateJSON() throws -> String?
+  func getEphemeralKeyInfo() throws -> String?
+  func getSharedSigalgs() throws -> String?
+  func isSessionReused() throws -> Bool
+  func getSession() throws -> ArrayBuffer?
+  func setSession(session: ArrayBuffer) throws -> Void
   func connectUnix(path: String) throws -> Void
+  func connectUnixTLS(path: String, serverName: String?, rejectUnauthorized: Bool?) throws -> Void
+  func connectUnixTLSWithContext(path: String, serverName: String?, rejectUnauthorized: Bool?, secureContextId: Double?) throws -> Void
   func write(data: ArrayBuffer) throws -> Void
   func pause() throws -> Void
   func resume() throws -> Void
@@ -24,6 +38,7 @@ public protocol HybridNetSocketDriverSpec_protocol: HybridObject {
   func setTimeout(timeout: Double) throws -> Void
   func destroy() throws -> Void
   func resetAndDestroy() throws -> Void
+  func enableKeylog() throws -> Void
   func setNoDelay(enable: Bool) throws -> Void
   func setKeepAlive(enable: Bool, delay: Double) throws -> Void
   func getLocalAddress() throws -> String

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,17 @@ 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 setNoDelay(enable: Bool) -> bridge.Result_void_ {
     do {

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

@@ -16,6 +16,14 @@ namespace margelo::nitro::net {
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("createSocket", &HybridNetDriverSpec::createSocket);
       prototype.registerHybridMethod("createServer", &HybridNetDriverSpec::createServer);
+      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

@@ -25,6 +25,7 @@ namespace margelo::nitro::net { struct NetConfig; }
 #include <string>
 #include <optional>
 #include "HybridNetServerDriverSpec.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
 #include "NetConfig.hpp"
 
 namespace margelo::nitro::net {
@@ -60,6 +61,14 @@ 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 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: