react-native-nitro-net 0.1.5 → 0.2.0

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

@@ -19,8 +19,10 @@ namespace margelo::nitro::net { struct NetConfig; }
 #include "JHybridNetSocketDriverSpec.hpp"
 #include "HybridNetServerDriverSpec.hpp"
 #include "JHybridNetServerDriverSpec.hpp"
-#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
 #include <optional>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <string>
 #include "NetConfig.hpp"
 #include "JNetConfig.hpp"
 
@@ -66,6 +68,41 @@ namespace margelo::nitro::net {
     auto __result = method(_javaPart);
     return __result->cthis()->shared_cast<JHybridNetServerDriverSpec>();
   }
+  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,14 @@ namespace margelo::nitro::net {
     // Methods
     std::shared_ptr<HybridNetSocketDriverSpec> createSocket(const std::optional<std::string>& id) override;
     std::shared_ptr<HybridNetServerDriverSpec> createServer() 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,6 +78,10 @@ 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);

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

@@ -58,6 +58,7 @@ 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 listenHandle(double fd, std::optional<double> backlog) override;
     std::string getLocalAddress() 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,10 @@ 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::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,7 @@ namespace margelo::nitro::net {
     void setTimeout(double timeout) override;
     void destroy() override;
     void resetAndDestroy() override;
+    void enableKeylog() override;
     void setNoDelay(bool enable) override;
     void setKeepAlive(bool enable, double delay) override;
     std::string getLocalAddress() override;

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,38 @@ abstract class HybridNetDriverSpec: HybridObject() {
   @Keep
   abstract fun createServer(): HybridNetServerDriverSpec
   
+  @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,6 +68,10 @@ 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

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,10 @@ abstract class HybridNetSocketDriverSpec: HybridObject() {
   @Keep
   abstract fun resetAndDestroy(): Unit
   
+  @DoNotStrip
+  @Keep
+  abstract fun enableKeylog(): Unit
+  
   @DoNotStrip
   @Keep
   abstract fun setNoDelay(enable: Boolean): Unit

package/nitrogen/generated/ios/RustCNet-Swift-Cxx-Bridge.hpp

@@ -44,6 +44,66 @@ namespace RustCNet { class HybridNetSocketDriverSpec_cxx; }
  */
 namespace margelo::nitro::net::bridge::swift {
 
+  // pragma MARK: std::optional<std::string>
+  /**
+   * Specialized version of `std::optional<std::string>`.
+   */
+  using std__optional_std__string_ = std::optional<std::string>;
+  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
+    return std::optional<std::string>(value);
+  }
+  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<bool>
+  /**
+   * Specialized version of `std::optional<bool>`.
+   */
+  using std__optional_bool_ = std::optional<bool>;
+  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
+    return std::optional<bool>(value);
+  }
+  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<double>
+  /**
+   * Specialized version of `std::optional<double>`.
+   */
+  using std__optional_double_ = std::optional<double>;
+  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
+    return std::optional<double>(value);
+  }
+  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
+    return *optional;
+  }
+  
+  // pragma MARK: std::optional<std::shared_ptr<ArrayBuffer>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<ArrayBuffer>>`.
+   */
+  using std__optional_std__shared_ptr_ArrayBuffer__ = std::optional<std::shared_ptr<ArrayBuffer>>;
+  inline std::optional<std::shared_ptr<ArrayBuffer>> create_std__optional_std__shared_ptr_ArrayBuffer__(const std::shared_ptr<ArrayBuffer>& value) noexcept {
+    return std::optional<std::shared_ptr<ArrayBuffer>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_ArrayBuffer__(const std::optional<std::shared_ptr<ArrayBuffer>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<ArrayBuffer> get_std__optional_std__shared_ptr_ArrayBuffer__(const std::optional<std::shared_ptr<ArrayBuffer>>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::function<void(double /* event */, const std::shared_ptr<ArrayBuffer>& /* data */)>
   /**
    * Specialized version of `std::function<void(double, const std::shared_ptr<ArrayBuffer>&)>`.
@@ -87,43 +147,40 @@ namespace margelo::nitro::net::bridge::swift {
     return Result<void>::withError(error);
   }
   
-  // pragma MARK: Result<std::string>
-  using Result_std__string_ = Result<std::string>;
-  inline Result_std__string_ create_Result_std__string_(const std::string& value) noexcept {
-    return Result<std::string>::withValue(value);
+  // pragma MARK: Result<std::optional<std::string>>
+  using Result_std__optional_std__string__ = Result<std::optional<std::string>>;
+  inline Result_std__optional_std__string__ create_Result_std__optional_std__string__(const std::optional<std::string>& value) noexcept {
+    return Result<std::optional<std::string>>::withValue(value);
   }
-  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
-    return Result<std::string>::withError(error);
+  inline Result_std__optional_std__string__ create_Result_std__optional_std__string__(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<std::string>>::withError(error);
   }
   
-  // pragma MARK: std::optional<double>
-  /**
-   * Specialized version of `std::optional<double>`.
-   */
-  using std__optional_double_ = std::optional<double>;
-  inline std::optional<double> create_std__optional_double_(const double& value) noexcept {
-    return std::optional<double>(value);
+  // pragma MARK: Result<bool>
+  using Result_bool_ = Result<bool>;
+  inline Result_bool_ create_Result_bool_(bool value) noexcept {
+    return Result<bool>::withValue(std::move(value));
   }
-  inline bool has_value_std__optional_double_(const std::optional<double>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
-    return *optional;
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
+    return Result<bool>::withError(error);
   }
   
-  // pragma MARK: std::optional<bool>
-  /**
-   * Specialized version of `std::optional<bool>`.
-   */
-  using std__optional_bool_ = std::optional<bool>;
-  inline std::optional<bool> create_std__optional_bool_(const bool& value) noexcept {
-    return std::optional<bool>(value);
+  // pragma MARK: Result<std::optional<std::shared_ptr<ArrayBuffer>>>
+  using Result_std__optional_std__shared_ptr_ArrayBuffer___ = Result<std::optional<std::shared_ptr<ArrayBuffer>>>;
+  inline Result_std__optional_std__shared_ptr_ArrayBuffer___ create_Result_std__optional_std__shared_ptr_ArrayBuffer___(const std::optional<std::shared_ptr<ArrayBuffer>>& value) noexcept {
+    return Result<std::optional<std::shared_ptr<ArrayBuffer>>>::withValue(value);
   }
-  inline bool has_value_std__optional_bool_(const std::optional<bool>& optional) noexcept {
-    return optional.has_value();
+  inline Result_std__optional_std__shared_ptr_ArrayBuffer___ create_Result_std__optional_std__shared_ptr_ArrayBuffer___(const std::exception_ptr& error) noexcept {
+    return Result<std::optional<std::shared_ptr<ArrayBuffer>>>::withError(error);
   }
-  inline bool get_std__optional_bool_(const std::optional<bool>& optional) noexcept {
-    return *optional;
+  
+  // pragma MARK: Result<std::string>
+  using Result_std__string_ = Result<std::string>;
+  inline Result_std__string_ create_Result_std__string_(const std::string& value) noexcept {
+    return Result<std::string>::withValue(value);
+  }
+  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
+    return Result<std::string>::withError(error);
   }
   
   // pragma MARK: std::shared_ptr<HybridNetServerDriverSpec>
@@ -138,21 +195,6 @@ namespace margelo::nitro::net::bridge::swift {
   using std__weak_ptr_HybridNetServerDriverSpec_ = std::weak_ptr<HybridNetServerDriverSpec>;
   inline std__weak_ptr_HybridNetServerDriverSpec_ weakify_std__shared_ptr_HybridNetServerDriverSpec_(const std::shared_ptr<HybridNetServerDriverSpec>& strong) noexcept { return strong; }
   
-  // pragma MARK: std::optional<std::string>
-  /**
-   * Specialized version of `std::optional<std::string>`.
-   */
-  using std__optional_std__string_ = std::optional<std::string>;
-  inline std::optional<std::string> create_std__optional_std__string_(const std::string& value) noexcept {
-    return std::optional<std::string>(value);
-  }
-  inline bool has_value_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return optional.has_value();
-  }
-  inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return *optional;
-  }
-  
   // pragma MARK: std::shared_ptr<HybridNetDriverSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridNetDriverSpec>`.
@@ -182,5 +224,14 @@ namespace margelo::nitro::net::bridge::swift {
   inline Result_std__shared_ptr_HybridNetServerDriverSpec__ create_Result_std__shared_ptr_HybridNetServerDriverSpec__(const std::exception_ptr& error) noexcept {
     return Result<std::shared_ptr<HybridNetServerDriverSpec>>::withError(error);
   }
+  
+  // pragma MARK: Result<double>
+  using Result_double_ = Result<double>;
+  inline Result_double_ create_Result_double_(double value) noexcept {
+    return Result<double>::withValue(std::move(value));
+  }
+  inline Result_double_ create_Result_double_(const std::exception_ptr& error) noexcept {
+    return Result<double>::withError(error);
+  }
 
 } // namespace margelo::nitro::net::bridge::swift

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

@@ -16,6 +16,8 @@ namespace RustCNet { class HybridNetDriverSpec_cxx; }
 namespace margelo::nitro::net { class HybridNetSocketDriverSpec; }
 // Forward declaration of `HybridNetServerDriverSpec` to properly resolve imports.
 namespace margelo::nitro::net { class HybridNetServerDriverSpec; }
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
 // Forward declaration of `NetConfig` to properly resolve imports.
 namespace margelo::nitro::net { struct NetConfig; }
 
@@ -24,6 +26,8 @@ namespace margelo::nitro::net { struct NetConfig; }
 #include <string>
 #include <optional>
 #include "HybridNetServerDriverSpec.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
 #include "NetConfig.hpp"
 
 #include "RustCNet-Swift-Cxx-Umbrella.hpp"
@@ -86,6 +90,60 @@ namespace margelo::nitro::net {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline double createSecureContext(const std::string& cert, const std::string& key, const std::optional<std::string>& passphrase) override {
+      auto __result = _swiftPart.createSecureContext(cert, key, passphrase);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline double createEmptySecureContext() override {
+      auto __result = _swiftPart.createEmptySecureContext();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void addCACertToSecureContext(double scId, const std::string& ca) override {
+      auto __result = _swiftPart.addCACertToSecureContext(std::forward<decltype(scId)>(scId), ca);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void addContextToSecureContext(double scId, const std::string& hostname, const std::string& cert, const std::string& key, const std::optional<std::string>& passphrase) override {
+      auto __result = _swiftPart.addContextToSecureContext(std::forward<decltype(scId)>(scId), hostname, cert, key, passphrase);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void setPFXToSecureContext(double scId, const std::shared_ptr<ArrayBuffer>& pfx, const std::optional<std::string>& passphrase) override {
+      auto __result = _swiftPart.setPFXToSecureContext(std::forward<decltype(scId)>(scId), ArrayBufferHolder(pfx), passphrase);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void setOCSPResponseToSecureContext(double scId, const std::shared_ptr<ArrayBuffer>& ocsp) override {
+      auto __result = _swiftPart.setOCSPResponseToSecureContext(std::forward<decltype(scId)>(scId), ArrayBufferHolder(ocsp));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::optional<std::shared_ptr<ArrayBuffer>> getTicketKeys(double scId) override {
+      auto __result = _swiftPart.getTicketKeys(std::forward<decltype(scId)>(scId));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline void setTicketKeys(double scId, const std::shared_ptr<ArrayBuffer>& keys) override {
+      auto __result = _swiftPart.setTicketKeys(std::forward<decltype(scId)>(scId), ArrayBufferHolder(keys));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void initWithConfig(const NetConfig& config) override {
       auto __result = _swiftPart.initWithConfig(std::forward<decltype(config)>(config));
       if (__result.hasError()) [[unlikely]] {

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

@@ -83,6 +83,12 @@ namespace margelo::nitro::net {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void listenTLS(double port, double secureContextId, std::optional<double> backlog, std::optional<bool> ipv6Only, std::optional<bool> reusePort) override {
+      auto __result = _swiftPart.listenTLS(std::forward<decltype(port)>(port), std::forward<decltype(secureContextId)>(secureContextId), backlog, ipv6Only, reusePort);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void listenUnix(const std::string& path, std::optional<double> backlog) override {
       auto __result = _swiftPart.listenUnix(path, backlog);
       if (__result.hasError()) [[unlikely]] {