react-native-nitro-net 0.1.5 → 0.3.0

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

@@ -8,6 +8,7 @@
 #include "RustCNet-Swift-Cxx-Bridge.hpp"
 
 // Include C++ implementation defined types
+#include "HybridHttpParserSpecSwift.hpp"
 #include "HybridNetDriverSpecSwift.hpp"
 #include "HybridNetServerDriverSpecSwift.hpp"
 #include "HybridNetSocketDriverSpecSwift.hpp"
@@ -56,6 +57,22 @@ namespace margelo::nitro::net::bridge::swift {
     return swiftPart.toUnsafe();
   }
   
+  // pragma MARK: std::shared_ptr<HybridHttpParserSpec>
+  std::shared_ptr<HybridHttpParserSpec> create_std__shared_ptr_HybridHttpParserSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    RustCNet::HybridHttpParserSpec_cxx swiftPart = RustCNet::HybridHttpParserSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::net::HybridHttpParserSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridHttpParserSpec_(std__shared_ptr_HybridHttpParserSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::net::HybridHttpParserSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::net::HybridHttpParserSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridHttpParserSpec\" is not implemented in Swift!");
+    }
+    #endif
+    RustCNet::HybridHttpParserSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+  
   // pragma MARK: std::shared_ptr<HybridNetDriverSpec>
   std::shared_ptr<HybridNetDriverSpec> create_std__shared_ptr_HybridNetDriverSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     RustCNet::HybridNetDriverSpec_cxx swiftPart = RustCNet::HybridNetDriverSpec_cxx::fromUnsafe(swiftUnsafePointer);

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

@@ -10,6 +10,8 @@
 // Forward declarations of C++ defined types
 // Forward declaration of `ArrayBufferHolder` to properly resolve imports.
 namespace NitroModules { class ArrayBufferHolder; }
+// Forward declaration of `HybridHttpParserSpec` to properly resolve imports.
+namespace margelo::nitro::net { class HybridHttpParserSpec; }
 // Forward declaration of `HybridNetDriverSpec` to properly resolve imports.
 namespace margelo::nitro::net { class HybridNetDriverSpec; }
 // Forward declaration of `HybridNetServerDriverSpec` to properly resolve imports.
@@ -18,6 +20,8 @@ namespace margelo::nitro::net { class HybridNetServerDriverSpec; }
 namespace margelo::nitro::net { class HybridNetSocketDriverSpec; }
 
 // Forward declarations of Swift defined types
+// Forward declaration of `HybridHttpParserSpec_cxx` to properly resolve imports.
+namespace RustCNet { class HybridHttpParserSpec_cxx; }
 // Forward declaration of `HybridNetDriverSpec_cxx` to properly resolve imports.
 namespace RustCNet { class HybridNetDriverSpec_cxx; }
 // Forward declaration of `HybridNetServerDriverSpec_cxx` to properly resolve imports.
@@ -26,6 +30,7 @@ namespace RustCNet { class HybridNetServerDriverSpec_cxx; }
 namespace RustCNet { class HybridNetSocketDriverSpec_cxx; }
 
 // Include C++ defined types
+#include "HybridHttpParserSpec.hpp"
 #include "HybridNetDriverSpec.hpp"
 #include "HybridNetServerDriverSpec.hpp"
 #include "HybridNetSocketDriverSpec.hpp"
@@ -44,6 +49,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 +152,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,20 +200,17 @@ 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>
+  // pragma MARK: std::shared_ptr<HybridHttpParserSpec>
   /**
-   * Specialized version of `std::optional<std::string>`.
+   * Specialized version of `std::shared_ptr<HybridHttpParserSpec>`.
    */
-  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;
-  }
+  using std__shared_ptr_HybridHttpParserSpec_ = std::shared_ptr<HybridHttpParserSpec>;
+  std::shared_ptr<HybridHttpParserSpec> create_std__shared_ptr_HybridHttpParserSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridHttpParserSpec_(std__shared_ptr_HybridHttpParserSpec_ cppType);
+  
+  // pragma MARK: std::weak_ptr<HybridHttpParserSpec>
+  using std__weak_ptr_HybridHttpParserSpec_ = std::weak_ptr<HybridHttpParserSpec>;
+  inline std__weak_ptr_HybridHttpParserSpec_ weakify_std__shared_ptr_HybridHttpParserSpec_(const std::shared_ptr<HybridHttpParserSpec>& strong) noexcept { return strong; }
   
   // pragma MARK: std::shared_ptr<HybridNetDriverSpec>
   /**
@@ -182,5 +241,23 @@ 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<std::shared_ptr<HybridHttpParserSpec>>
+  using Result_std__shared_ptr_HybridHttpParserSpec__ = Result<std::shared_ptr<HybridHttpParserSpec>>;
+  inline Result_std__shared_ptr_HybridHttpParserSpec__ create_Result_std__shared_ptr_HybridHttpParserSpec__(const std::shared_ptr<HybridHttpParserSpec>& value) noexcept {
+    return Result<std::shared_ptr<HybridHttpParserSpec>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_HybridHttpParserSpec__ create_Result_std__shared_ptr_HybridHttpParserSpec__(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<HybridHttpParserSpec>>::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/RustCNet-Swift-Cxx-Umbrella.hpp

@@ -8,6 +8,8 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `HybridHttpParserSpec` to properly resolve imports.
+namespace margelo::nitro::net { class HybridHttpParserSpec; }
 // Forward declaration of `HybridNetDriverSpec` to properly resolve imports.
 namespace margelo::nitro::net { class HybridNetDriverSpec; }
 // Forward declaration of `HybridNetServerDriverSpec` to properly resolve imports.
@@ -18,6 +20,7 @@ namespace margelo::nitro::net { class HybridNetSocketDriverSpec; }
 namespace margelo::nitro::net { struct NetConfig; }
 
 // Include C++ defined types
+#include "HybridHttpParserSpec.hpp"
 #include "HybridNetDriverSpec.hpp"
 #include "HybridNetServerDriverSpec.hpp"
 #include "HybridNetSocketDriverSpec.hpp"
@@ -40,6 +43,8 @@ namespace margelo::nitro::net { struct NetConfig; }
 #include <NitroModules/DateToChronoDate.hpp>
 
 // Forward declarations of Swift defined types
+// Forward declaration of `HybridHttpParserSpec_cxx` to properly resolve imports.
+namespace RustCNet { class HybridHttpParserSpec_cxx; }
 // Forward declaration of `HybridNetDriverSpec_cxx` to properly resolve imports.
 namespace RustCNet { class HybridNetDriverSpec_cxx; }
 // Forward declaration of `HybridNetServerDriverSpec_cxx` to properly resolve imports.

package/nitrogen/generated/ios/c++/HybridHttpParserSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridHttpParserSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridHttpParserSpecSwift.hpp"
+
+namespace margelo::nitro::net {
+} // namespace margelo::nitro::net

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

@@ -0,0 +1,79 @@
+///
+/// HybridHttpParserSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridHttpParserSpec.hpp"
+
+// Forward declaration of `HybridHttpParserSpec_cxx` to properly resolve imports.
+namespace RustCNet { class HybridHttpParserSpec_cxx; }
+
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
+
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
+
+#include "RustCNet-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::net {
+
+  /**
+   * The C++ part of HybridHttpParserSpec_cxx.swift.
+   *
+   * HybridHttpParserSpecSwift (C++) accesses HybridHttpParserSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridHttpParserSpec_cxx can directly inherit from the C++ class HybridHttpParserSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridHttpParserSpecSwift: public virtual HybridHttpParserSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridHttpParserSpecSwift(const RustCNet::HybridHttpParserSpec_cxx& swiftPart):
+      HybridObject(HybridHttpParserSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline RustCNet::HybridHttpParserSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::string feed(const std::shared_ptr<ArrayBuffer>& data) override {
+      auto __result = _swiftPart.feed(ArrayBufferHolder(data));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    RustCNet::HybridHttpParserSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::net

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

@@ -16,6 +16,10 @@ 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 `HybridHttpParserSpec` to properly resolve imports.
+namespace margelo::nitro::net { class HybridHttpParserSpec; }
+// 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 +28,9 @@ namespace margelo::nitro::net { struct NetConfig; }
 #include <string>
 #include <optional>
 #include "HybridNetServerDriverSpec.hpp"
+#include "HybridHttpParserSpec.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
 #include "NetConfig.hpp"
 
 #include "RustCNet-Swift-Cxx-Umbrella.hpp"
@@ -86,6 +93,68 @@ namespace margelo::nitro::net {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline std::shared_ptr<HybridHttpParserSpec> createHttpParser(double mode) override {
+      auto __result = _swiftPart.createHttpParser(std::forward<decltype(mode)>(mode));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      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,12 +83,24 @@ 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]] {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void listenTLSUnix(const std::string& path, double secureContextId, std::optional<double> backlog) override {
+      auto __result = _swiftPart.listenTLSUnix(path, std::forward<decltype(secureContextId)>(secureContextId), backlog);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
     inline void listenHandle(double fd, std::optional<double> backlog) override {
       auto __result = _swiftPart.listenHandle(std::forward<decltype(fd)>(fd), backlog);
       if (__result.hasError()) [[unlikely]] {

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,26 @@ 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 enableTrace() override {
+      auto __result = _swiftPart.enableTrace();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::optional<std::shared_ptr<ArrayBuffer>> exportKeyingMaterial(double length, const std::string& label, const std::optional<std::shared_ptr<ArrayBuffer>>& context) override {
+      auto __result = _swiftPart.exportKeyingMaterial(std::forward<decltype(length)>(length), label, context);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline void setNoDelay(bool enable) override {
       auto __result = _swiftPart.setNoDelay(std::forward<decltype(enable)>(enable));
       if (__result.hasError()) [[unlikely]] {