react-nitro-networking 0.0.0-stage → 0.0.1-alpha.7

package/nitrogen/generated/apple/ReactNitroNetworking-Swift-Cxx-Bridge.cpp

@@ -0,0 +1,171 @@
+///
+/// ReactNitroNetworking-Swift-Cxx-Bridge.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+#include <ReactNitroNetworking/private/ReactNitroNetworking-Swift-Cxx-Umbrella.hpp>
+#include <ReactNitroNetworking/private/HybridNetworkingSpecSwift.hpp>
+#include <ReactNitroNetworking/private/HybridResponseSpecSwift.hpp>
+
+#include <ReactNitroNetworking/private/HybridResponseSpec_cxx-Swift.hpp>
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/NitroModules-Swift-Cxx-Umbrella.hpp>
+#include <NitroModules/JSIConverter+SwiftAnyJSON.hpp>
+#include <NitroModules/JSIConverter+SwiftString.hpp>
+#include <ReactNitroNetworking/private/HybridWebSocketSpecSwift.hpp>
+#include <NitroModules/Callback.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <ReactNitroNetworking/private/Variant_ArrayBuffer_String-Swift.hpp>
+#include <NitroModules/SwiftResult.hpp>
+#include <exception>
+
+namespace margelo::nitro::networking::swift_bridge {
+  std__shared_ptr_margelo__nitro__networking__HybridNetworkingSpec_ create_std__shared_ptr_margelo__nitro__networking__HybridNetworkingSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::networking::HybridNetworkingSpecSwift>(::ReactNitroNetworking::HybridNetworkingSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__networking__HybridNetworkingSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::networking::HybridNetworkingSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridNetworkingSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  std__shared_ptr_margelo__nitro__networking__HybridResponseSpec_ create_std__shared_ptr_margelo__nitro__networking__HybridResponseSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::networking::HybridResponseSpecSwift>(::ReactNitroNetworking::HybridResponseSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__networking__HybridResponseSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::networking::HybridResponseSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridResponseSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  Promise___ReactNitroNetworking__HybridResponseSpec_cxx create_Promise___ReactNitroNetworking__HybridResponseSpec_cxx() { return Promise___ReactNitroNetworking__HybridResponseSpec_cxx::pending(); }
+
+  void reject_Promise___ReactNitroNetworking__HybridResponseSpec_cxx(const Promise___ReactNitroNetworking__HybridResponseSpec_cxx& promise, std::exception_ptr error) { promise.reject(std::move(error)); }
+
+  void listenRejected_Promise___ReactNitroNetworking__HybridResponseSpec_cxx(const Promise___ReactNitroNetworking__HybridResponseSpec_cxx& promise, std::function<void(const std::exception_ptr&)> listener) { promise.addOnRejectedListener(std::move(listener)); }
+
+  void resolve_Promise___ReactNitroNetworking__HybridResponseSpec_cxx(const Promise___ReactNitroNetworking__HybridResponseSpec_cxx& promise, const void* NON_NULL value) {
+    promise.resolve(NitroModules::copySwiftValue<::ReactNitroNetworking::HybridResponseSpec_cxx>(value));
+  }
+
+  void listen_Promise___ReactNitroNetworking__HybridResponseSpec_cxx(const Promise___ReactNitroNetworking__HybridResponseSpec_cxx& promise, std::function<void(const void* NON_NULL)> listener) {
+    promise.addOnResolvedListener([listener = std::move(listener)](const ::ReactNitroNetworking::HybridResponseSpec_cxx& value) {
+      NitroModules::withSwiftValue(value, [&](const void* pointer) {
+        listener(pointer);
+      });
+    });
+  }
+
+  Promise_NitroModules__AnyJSON create_Promise_NitroModules__AnyJSON() { return Promise_NitroModules__AnyJSON::pending(); }
+
+  void reject_Promise_NitroModules__AnyJSON(const Promise_NitroModules__AnyJSON& promise, std::exception_ptr error) { promise.reject(std::move(error)); }
+
+  void listenRejected_Promise_NitroModules__AnyJSON(const Promise_NitroModules__AnyJSON& promise, std::function<void(const std::exception_ptr&)> listener) { promise.addOnRejectedListener(std::move(listener)); }
+
+  void resolve_Promise_NitroModules__AnyJSON(const Promise_NitroModules__AnyJSON& promise, const void* NON_NULL value) {
+    promise.resolve(NitroModules::copySwiftValue<NitroModules::AnyJSON>(value));
+  }
+
+  void listen_Promise_NitroModules__AnyJSON(const Promise_NitroModules__AnyJSON& promise, std::function<void(const void* NON_NULL)> listener) {
+    promise.addOnResolvedListener([listener = std::move(listener)](const NitroModules::AnyJSON& value) {
+      NitroModules::withSwiftValue(value, [&](const void* pointer) {
+        listener(pointer);
+      });
+    });
+  }
+
+  Promise_swift__String create_Promise_swift__String() { return Promise_swift__String::pending(); }
+
+  void reject_Promise_swift__String(const Promise_swift__String& promise, std::exception_ptr error) { promise.reject(std::move(error)); }
+
+  void listenRejected_Promise_swift__String(const Promise_swift__String& promise, std::function<void(const std::exception_ptr&)> listener) { promise.addOnRejectedListener(std::move(listener)); }
+
+  void resolve_Promise_swift__String(const Promise_swift__String& promise, const void* NON_NULL value) {
+    promise.resolve(NitroModules::copySwiftValue<swift::String>(value));
+  }
+
+  void listen_Promise_swift__String(const Promise_swift__String& promise, std::function<void(const void* NON_NULL)> listener) {
+    promise.addOnResolvedListener([listener = std::move(listener)](const swift::String& value) {
+      NitroModules::withSwiftValue(value, [&](const void* pointer) {
+        listener(pointer);
+      });
+    });
+  }
+
+  std__shared_ptr_margelo__nitro__networking__HybridWebSocketSpec_ create_std__shared_ptr_margelo__nitro__networking__HybridWebSocketSpec_(void* NON_NULL pointer) {
+    return std::make_shared<margelo::nitro::networking::HybridWebSocketSpecSwift>(::ReactNitroNetworking::HybridWebSocketSpec_cxx::fromUnsafe(pointer));
+  }
+
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__networking__HybridWebSocketSpec_(const std::shared_ptr<HybridObject>& value) {
+    auto wrapper = std::dynamic_pointer_cast<margelo::nitro::networking::HybridWebSocketSpecSwift>(value);
+    if (!wrapper) throw std::runtime_error("HybridWebSocketSpec is not implemented in Swift");
+    return wrapper->getSwiftPart().toUnsafe();
+  }
+
+  Result<void, margelo::nitro::networking::swift_bridge::ResultTag> callSync_Callback_void(const Callback_void& callback) noexcept {
+    try {
+      callback.callSync();
+      return Result<void, margelo::nitro::networking::swift_bridge::ResultTag>::withValue();
+    } catch (...) {
+      return Result<void, margelo::nitro::networking::swift_bridge::ResultTag>::withError(std::current_exception());
+    }
+  }
+
+  Callback_void create_Callback_void(std::function<Result<void, margelo::nitro::networking::swift_bridge::ResultTag>()> closure) {
+    return Callback_void::make([closure = std::move(closure)]() -> void {
+      auto __result = closure();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    });
+  }
+
+  Result<void, margelo::nitro::networking::swift_bridge::ResultTag> callSync_Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx(const Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx& callback, const void* NON_NULL param0) noexcept {
+    try {
+      callback.callSync(NitroModules::copySwiftValue<::ReactNitroNetworking::Variant_ArrayBuffer_String_cxx>(param0));
+      return Result<void, margelo::nitro::networking::swift_bridge::ResultTag>::withValue();
+    } catch (...) {
+      return Result<void, margelo::nitro::networking::swift_bridge::ResultTag>::withError(std::current_exception());
+    }
+  }
+
+  Promise<void> callAsync_Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx(const Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx& callback, const void* NON_NULL param0) {
+    return callback.callAsync(NitroModules::copySwiftValue<::ReactNitroNetworking::Variant_ArrayBuffer_String_cxx>(param0));
+  }
+
+  void callAndForget_Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx(const Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx& callback, const void* NON_NULL param0) {
+    callback.callAndForget(NitroModules::copySwiftValue<::ReactNitroNetworking::Variant_ArrayBuffer_String_cxx>(param0));
+  }
+
+  Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx create_Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx(std::function<Result<void, margelo::nitro::networking::swift_bridge::ResultTag>(const void* NON_NULL param0)> closure) {
+    return Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx::make([closure = std::move(closure)](const ::ReactNitroNetworking::Variant_ArrayBuffer_String_cxx& param0) -> void {
+      auto __result = borrowSwiftValue(param0, [&](const void* param0) {
+        return closure(param0);
+      });
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    });
+  }
+
+  Result<void, margelo::nitro::networking::swift_bridge::ResultTag> callSync_Callback_void_std__exception_ptr(const Callback_void_std__exception_ptr& callback, const std::exception_ptr& param0) noexcept {
+    try {
+      callback.callSync(param0);
+      return Result<void, margelo::nitro::networking::swift_bridge::ResultTag>::withValue();
+    } catch (...) {
+      return Result<void, margelo::nitro::networking::swift_bridge::ResultTag>::withError(std::current_exception());
+    }
+  }
+
+  Callback_void_std__exception_ptr create_Callback_void_std__exception_ptr(std::function<Result<void, margelo::nitro::networking::swift_bridge::ResultTag>(const std::exception_ptr& param0)> closure) {
+    return Callback_void_std__exception_ptr::make([closure = std::move(closure)](const std::exception_ptr& param0) -> void {
+      auto __result = closure(param0);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    });
+  }
+} // namespace margelo::nitro::networking::swift_bridge

package/nitrogen/generated/apple/ReactNitroNetworkingAppleCxx/ReactNitroNetworkingAppleCxx.cpp

@@ -0,0 +1,9 @@
+///
+/// ReactNitroNetworkingAppleCxx.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+// Swift packages require at least one source file per C++ target.
+#include <ReactNitroNetworkingAppleCxx/ReactNitroNetworkingAppleCxx.h>

package/nitrogen/generated/apple/ReactNitroNetworkingAppleCxx/include/ReactNitroNetworkingAppleCxx/ReactNitroNetworkingAppleCxx.h

@@ -0,0 +1,97 @@
+///
+/// ReactNitroNetworkingAppleCxx.h
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+// Forward declaration of `HybridNetworkingSpec_cxx` to properly resolve imports.
+namespace ReactNitroNetworking { class HybridNetworkingSpec_cxx; }
+// Forward declaration of `HybridResponseSpec_cxx` to properly resolve imports.
+namespace ReactNitroNetworking { class HybridResponseSpec_cxx; }
+#include <NitroModules/Promise.hpp>
+namespace swift { class String; }
+#include <NitroModules/Result.hpp>
+// Forward declaration of `Record_swift__String_swift__String` to properly resolve imports.
+namespace ReactNitroNetworking { class Record_swift__String_swift__String; }
+// Forward declaration of `ResponseType` to properly resolve imports.
+namespace ReactNitroNetworking { class ResponseType; }
+#include <NitroModules/ArrayBuffer.hpp>
+namespace NitroModules { class AnyJSON; }
+// Forward declaration of `HybridWebSocketSpec_cxx` to properly resolve imports.
+namespace ReactNitroNetworking { class HybridWebSocketSpec_cxx; }
+#include <NitroModules/Callback.hpp>
+// Forward declaration of `ListenerSubscription` to properly resolve imports.
+namespace ReactNitroNetworking { class ListenerSubscription; }
+// Forward declaration of `Variant_ArrayBuffer_String_cxx` to properly resolve imports.
+namespace ReactNitroNetworking { class Variant_ArrayBuffer_String_cxx; }
+#include <exception>
+#include <NitroModules/HybridObject.hpp>
+// Forward declaration of `HybridNetworkingSpecSwift` to properly resolve imports.
+namespace margelo::nitro::networking { class HybridNetworkingSpecSwift; }
+#include <NitroModules/NitroDefines.hpp>
+// Forward declaration of `HybridResponseSpecSwift` to properly resolve imports.
+namespace margelo::nitro::networking { class HybridResponseSpecSwift; }
+// Forward declaration of `HybridWebSocketSpecSwift` to properly resolve imports.
+namespace margelo::nitro::networking { class HybridWebSocketSpecSwift; }
+
+namespace margelo::nitro::networking::swift_bridge {
+  using std__shared_ptr_margelo__nitro__networking__HybridNetworkingSpec_ = std::shared_ptr<margelo::nitro::networking::HybridNetworkingSpecSwift>;
+  using std__weak_ptr_margelo__nitro__networking__HybridNetworkingSpec_ = std::weak_ptr<margelo::nitro::networking::HybridNetworkingSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__networking__HybridNetworkingSpec_ weakify_std__shared_ptr_margelo__nitro__networking__HybridNetworkingSpec_(const std__shared_ptr_margelo__nitro__networking__HybridNetworkingSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__networking__HybridNetworkingSpec_ create_std__shared_ptr_margelo__nitro__networking__HybridNetworkingSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__networking__HybridNetworkingSpec_(const std::shared_ptr<HybridObject>& value);
+  using std__shared_ptr_margelo__nitro__networking__HybridResponseSpec_ = std::shared_ptr<margelo::nitro::networking::HybridResponseSpecSwift>;
+  using std__weak_ptr_margelo__nitro__networking__HybridResponseSpec_ = std::weak_ptr<margelo::nitro::networking::HybridResponseSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__networking__HybridResponseSpec_ weakify_std__shared_ptr_margelo__nitro__networking__HybridResponseSpec_(const std__shared_ptr_margelo__nitro__networking__HybridResponseSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__networking__HybridResponseSpec_ create_std__shared_ptr_margelo__nitro__networking__HybridResponseSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__networking__HybridResponseSpec_(const std::shared_ptr<HybridObject>& value);
+  using Promise___ReactNitroNetworking__HybridResponseSpec_cxx = Promise<::ReactNitroNetworking::HybridResponseSpec_cxx>;
+  Promise___ReactNitroNetworking__HybridResponseSpec_cxx create_Promise___ReactNitroNetworking__HybridResponseSpec_cxx();
+  void reject_Promise___ReactNitroNetworking__HybridResponseSpec_cxx(const Promise___ReactNitroNetworking__HybridResponseSpec_cxx& promise, std::exception_ptr error);
+  void listenRejected_Promise___ReactNitroNetworking__HybridResponseSpec_cxx(const Promise___ReactNitroNetworking__HybridResponseSpec_cxx& promise, std::function<void(const std::exception_ptr&)> listener);
+  void resolve_Promise___ReactNitroNetworking__HybridResponseSpec_cxx(const Promise___ReactNitroNetworking__HybridResponseSpec_cxx& promise, const void* NON_NULL value);
+  void listen_Promise___ReactNitroNetworking__HybridResponseSpec_cxx(const Promise___ReactNitroNetworking__HybridResponseSpec_cxx& promise, std::function<void(const void* NON_NULL)> listener);
+  // Distinct specializations prevent duplicate Swift metadata across module headers.
+  struct ResultTag {};
+  using Result_void = Result<void, margelo::nitro::networking::swift_bridge::ResultTag>;
+  using Promise_ArrayBuffer = Promise<ArrayBuffer>;
+  using Promise_NitroModules__AnyJSON = Promise<NitroModules::AnyJSON>;
+  Promise_NitroModules__AnyJSON create_Promise_NitroModules__AnyJSON();
+  void reject_Promise_NitroModules__AnyJSON(const Promise_NitroModules__AnyJSON& promise, std::exception_ptr error);
+  void listenRejected_Promise_NitroModules__AnyJSON(const Promise_NitroModules__AnyJSON& promise, std::function<void(const std::exception_ptr&)> listener);
+  void resolve_Promise_NitroModules__AnyJSON(const Promise_NitroModules__AnyJSON& promise, const void* NON_NULL value);
+  void listen_Promise_NitroModules__AnyJSON(const Promise_NitroModules__AnyJSON& promise, std::function<void(const void* NON_NULL)> listener);
+  using Promise_swift__String = Promise<swift::String>;
+  Promise_swift__String create_Promise_swift__String();
+  void reject_Promise_swift__String(const Promise_swift__String& promise, std::exception_ptr error);
+  void listenRejected_Promise_swift__String(const Promise_swift__String& promise, std::function<void(const std::exception_ptr&)> listener);
+  void resolve_Promise_swift__String(const Promise_swift__String& promise, const void* NON_NULL value);
+  void listen_Promise_swift__String(const Promise_swift__String& promise, std::function<void(const void* NON_NULL)> listener);
+  using std__shared_ptr_margelo__nitro__networking__HybridWebSocketSpec_ = std::shared_ptr<margelo::nitro::networking::HybridWebSocketSpecSwift>;
+  using std__weak_ptr_margelo__nitro__networking__HybridWebSocketSpec_ = std::weak_ptr<margelo::nitro::networking::HybridWebSocketSpecSwift>;
+  inline std__weak_ptr_margelo__nitro__networking__HybridWebSocketSpec_ weakify_std__shared_ptr_margelo__nitro__networking__HybridWebSocketSpec_(const std__shared_ptr_margelo__nitro__networking__HybridWebSocketSpec_& value) {
+    return value;
+  }
+  std__shared_ptr_margelo__nitro__networking__HybridWebSocketSpec_ create_std__shared_ptr_margelo__nitro__networking__HybridWebSocketSpec_(void* NON_NULL pointer);
+  void* NON_NULL get_std__shared_ptr_margelo__nitro__networking__HybridWebSocketSpec_(const std::shared_ptr<HybridObject>& value);
+  using Promise_void = Promise<void>;
+  using Callback_void = Callback<void()>;
+  Result<void, margelo::nitro::networking::swift_bridge::ResultTag> callSync_Callback_void(const Callback_void& callback) noexcept;
+  Callback_void create_Callback_void(std::function<Result<void, margelo::nitro::networking::swift_bridge::ResultTag>()> closure);
+  using Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx = Callback<void(const ::ReactNitroNetworking::Variant_ArrayBuffer_String_cxx&)>;
+  Result<void, margelo::nitro::networking::swift_bridge::ResultTag> callSync_Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx(const Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx& callback, const void* NON_NULL param0) noexcept;
+  Promise<void> callAsync_Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx(const Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx& callback, const void* NON_NULL param0);
+  void callAndForget_Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx(const Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx& callback, const void* NON_NULL param0);
+  Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx create_Callback_void___ReactNitroNetworking__Variant_ArrayBuffer_String_cxx(std::function<Result<void, margelo::nitro::networking::swift_bridge::ResultTag>(const void* NON_NULL param0)> closure);
+  using Callback_void_std__exception_ptr = Callback<void(const std::exception_ptr&)>;
+  Result<void, margelo::nitro::networking::swift_bridge::ResultTag> callSync_Callback_void_std__exception_ptr(const Callback_void_std__exception_ptr& callback, const std::exception_ptr& param0) noexcept;
+  Callback_void_std__exception_ptr create_Callback_void_std__exception_ptr(std::function<Result<void, margelo::nitro::networking::swift_bridge::ResultTag>(const std::exception_ptr& param0)> closure);
+  using Result_void_ = Result<void*, margelo::nitro::networking::swift_bridge::ResultTag>;
+} // namespace margelo::nitro::networking::swift_bridge

package/nitrogen/generated/apple/ReactNitroNetworkingAutolinking.cpp

@@ -0,0 +1,24 @@
+///
+/// ReactNitroNetworkingAutolinking.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroNetworking/ReactNitroNetworkingAutolinking.hpp>
+#include <NitroModules/HybridClassRegistry.hpp>
+
+#include <ReactNitroNetworking/private/HybridNetworkingSpecSwift.hpp>
+#include <ReactNitroNetworking/private/HybridResponseSpecSwift.hpp>
+#include <ReactNitroNetworking/private/HybridWebSocketSpecSwift.hpp>
+
+namespace margelo::nitro::networking {
+  void registerHybridClasses() {
+    using namespace margelo::nitro;
+    using namespace margelo::nitro::networking;
+
+    HybridClassRegistry::registerHybridClass("networking.Networking", HybridNetworkingSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("networking.Response", HybridResponseSpecSwift::Class::get());
+    HybridClassRegistry::registerHybridClass("networking.WebSocket", HybridWebSocketSpecSwift::Class::get());
+  }
+} // namespace margelo::nitro::networking

package/nitrogen/generated/apple/ReactNitroNetworkingAutolinking.mm

@@ -0,0 +1,24 @@
+///
+/// ReactNitroNetworkingAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#include <ReactNitroNetworking/ReactNitroNetworkingAutolinking.hpp>
+
+/**
+ * Registers all HybridObject classes of ReactNitroNetworking
+ * when the app loads, so JS can look them up by name.
+ */
+@interface ReactNitroNetworkingAutolinking : NSObject
+@end
+
+@implementation ReactNitroNetworkingAutolinking
+
++ (void)load {
+  margelo::nitro::networking::registerHybridClasses();
+}
+
+@end

package/nitrogen/generated/apple/c++/HybridNetworkingSpecSwift.cpp

@@ -0,0 +1,42 @@
+///
+/// HybridNetworkingSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroNetworking/private/HybridNetworkingSpecSwift.hpp>
+#include <NitroModules/SwiftConverter.hpp>
+#include <NitroModules/SwiftResult.hpp>
+#include <optional>
+
+namespace margelo::nitro::networking {
+
+  std::string HybridNetworkingSpecSwift::toString() {
+    return SwiftConverter<std::string, swift::String>::fromSwift(_swiftPart.toString());
+  }
+
+  // Properties
+
+  // Methods
+
+  // Static methods
+
+  Promise<::ReactNitroNetworking::HybridResponseSpec_cxx> HybridNetworkingSpecSwift::fetch(const swift::String& url) {
+    auto __result = withCxxResult<Promise<::ReactNitroNetworking::HybridResponseSpec_cxx>>([&](void* __outResult) {
+      return ::ReactNitroNetworking::HybridNetworkingSpec_cxx::fetch(url, __outResult);
+    });
+    if (__result.hasError()) [[unlikely]] {
+      std::rethrow_exception(__result.error());
+    }
+    return std::move(__result.value());
+  }
+
+  const std::shared_ptr<const HybridClass>& HybridNetworkingSpecSwift::Class::get() {
+    static const auto hybridClass = HybridClass::create<Class>([](HybridClass& clazz) {
+      clazz.registerStaticHybridMethod("fetch", &HybridNetworkingSpecSwift::fetch);
+    });
+    return hybridClass;
+  }
+
+} // namespace margelo::nitro::networking

package/nitrogen/generated/apple/c++/HybridNetworkingSpec_cxx-Swift.cpp

@@ -0,0 +1,28 @@
+///
+/// HybridNetworkingSpec_cxx-Swift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroNetworking/private/HybridNetworkingSpec_cxx-Swift.hpp>
+#include <ReactNitroNetworking/private/ReactNitroNetworking-Swift-Cxx-Umbrella.hpp>
+#include <ReactNitroNetworking/private/HybridNetworkingSpecSwift.hpp>
+
+namespace margelo::nitro {
+
+  ::ReactNitroNetworking::HybridNetworkingSpec_cxx JSIConverter<::ReactNitroNetworking::HybridNetworkingSpec_cxx>::fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+    auto hybridSpec = JSIConverter<std::shared_ptr<margelo::nitro::networking::HybridNetworkingSpecSwift>>::fromJSI(runtime, value);
+    return ::ReactNitroNetworking::HybridNetworkingSpec_cxx::fromUnsafe(margelo::nitro::networking::swift_bridge::get_std__shared_ptr_margelo__nitro__networking__HybridNetworkingSpec_(hybridSpec));
+  }
+
+  jsi::Value JSIConverter<::ReactNitroNetworking::HybridNetworkingSpec_cxx>::toJSI(jsi::Runtime& runtime, const ::ReactNitroNetworking::HybridNetworkingSpec_cxx& value) {
+    auto hybridSpec = ::ReactNitroNetworking::HybridNetworkingSpec_cxx::getCxxPart(value);
+    return JSIConverter<std::shared_ptr<margelo::nitro::networking::HybridNetworkingSpecSwift>>::toJSI(runtime, hybridSpec);
+  }
+
+  bool JSIConverter<::ReactNitroNetworking::HybridNetworkingSpec_cxx>::canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    return JSIConverter<std::shared_ptr<margelo::nitro::networking::HybridNetworkingSpecSwift>>::canConvert(runtime, value);
+  }
+
+} // namespace margelo::nitro

package/nitrogen/generated/apple/c++/HybridResponseSpecSwift.cpp

@@ -0,0 +1,102 @@
+///
+/// HybridResponseSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroNetworking/private/HybridResponseSpecSwift.hpp>
+#include <NitroModules/SwiftConverter.hpp>
+#include <NitroModules/SwiftResult.hpp>
+#include <optional>
+
+namespace margelo::nitro::networking {
+
+  std::string HybridResponseSpecSwift::toString() {
+    return SwiftConverter<std::string, swift::String>::fromSwift(_swiftPart.toString());
+  }
+
+  // Properties
+
+  ::ReactNitroNetworking::Record_swift__String_swift__String HybridResponseSpecSwift::getHeaders() {
+    return _swiftPart.getHeaders();
+  }
+
+  double HybridResponseSpecSwift::getStatus() {
+    return _swiftPart.getStatus();
+  }
+
+  bool HybridResponseSpecSwift::getOk() {
+    return _swiftPart.getOk();
+  }
+
+  swift::String HybridResponseSpecSwift::getStatusText() {
+    return _swiftPart.getStatusText();
+  }
+
+  swift::String HybridResponseSpecSwift::getUrl() {
+    return _swiftPart.getUrl();
+  }
+
+  bool HybridResponseSpecSwift::getRedirected() {
+    return _swiftPart.getRedirected();
+  }
+
+  ::ReactNitroNetworking::ResponseType HybridResponseSpecSwift::getType() {
+    return _swiftPart.getType();
+  }
+
+  bool HybridResponseSpecSwift::getBodyUsed() {
+    return _swiftPart.getBodyUsed();
+  }
+
+  // Methods
+
+  Promise<ArrayBuffer> HybridResponseSpecSwift::arrayBuffer() {
+    auto __result = withCxxResult<Promise<ArrayBuffer>>([&](void* __outResult) {
+      return _swiftPart.arrayBuffer(__outResult);
+    });
+    if (__result.hasError()) [[unlikely]] {
+      std::rethrow_exception(__result.error());
+    }
+    return std::move(__result.value());
+  }
+
+  Promise<NitroModules::AnyJSON> HybridResponseSpecSwift::json() {
+    auto __result = withCxxResult<Promise<NitroModules::AnyJSON>>([&](void* __outResult) {
+      return _swiftPart.json(__outResult);
+    });
+    if (__result.hasError()) [[unlikely]] {
+      std::rethrow_exception(__result.error());
+    }
+    return std::move(__result.value());
+  }
+
+  Promise<swift::String> HybridResponseSpecSwift::text() {
+    auto __result = withCxxResult<Promise<swift::String>>([&](void* __outResult) {
+      return _swiftPart.text(__outResult);
+    });
+    if (__result.hasError()) [[unlikely]] {
+      std::rethrow_exception(__result.error());
+    }
+    return std::move(__result.value());
+  }
+
+  const std::shared_ptr<const HybridClass>& HybridResponseSpecSwift::Class::get() {
+    static const auto hybridClass = HybridClass::create<Class>([](HybridClass& clazz) {
+      clazz.registerHybridProperty("headers", &HybridResponseSpecSwift::getHeaders);
+      clazz.registerHybridProperty("status", &HybridResponseSpecSwift::getStatus);
+      clazz.registerHybridProperty("ok", &HybridResponseSpecSwift::getOk);
+      clazz.registerHybridProperty("statusText", &HybridResponseSpecSwift::getStatusText);
+      clazz.registerHybridProperty("url", &HybridResponseSpecSwift::getUrl);
+      clazz.registerHybridProperty("redirected", &HybridResponseSpecSwift::getRedirected);
+      clazz.registerHybridProperty("type", &HybridResponseSpecSwift::getType);
+      clazz.registerHybridProperty("bodyUsed", &HybridResponseSpecSwift::getBodyUsed);
+      clazz.registerHybridMethod("arrayBuffer", &HybridResponseSpecSwift::arrayBuffer);
+      clazz.registerHybridMethod("json", &HybridResponseSpecSwift::json);
+      clazz.registerHybridMethod("text", &HybridResponseSpecSwift::text);
+    });
+    return hybridClass;
+  }
+
+} // namespace margelo::nitro::networking

package/nitrogen/generated/apple/c++/HybridResponseSpec_cxx-Swift.cpp

@@ -0,0 +1,28 @@
+///
+/// HybridResponseSpec_cxx-Swift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroNetworking/private/HybridResponseSpec_cxx-Swift.hpp>
+#include <ReactNitroNetworking/private/ReactNitroNetworking-Swift-Cxx-Umbrella.hpp>
+#include <ReactNitroNetworking/private/HybridResponseSpecSwift.hpp>
+
+namespace margelo::nitro {
+
+  ::ReactNitroNetworking::HybridResponseSpec_cxx JSIConverter<::ReactNitroNetworking::HybridResponseSpec_cxx>::fromJSI(jsi::Runtime& runtime, const jsi::Value& value) {
+    auto hybridSpec = JSIConverter<std::shared_ptr<margelo::nitro::networking::HybridResponseSpecSwift>>::fromJSI(runtime, value);
+    return ::ReactNitroNetworking::HybridResponseSpec_cxx::fromUnsafe(margelo::nitro::networking::swift_bridge::get_std__shared_ptr_margelo__nitro__networking__HybridResponseSpec_(hybridSpec));
+  }
+
+  jsi::Value JSIConverter<::ReactNitroNetworking::HybridResponseSpec_cxx>::toJSI(jsi::Runtime& runtime, const ::ReactNitroNetworking::HybridResponseSpec_cxx& value) {
+    auto hybridSpec = ::ReactNitroNetworking::HybridResponseSpec_cxx::getCxxPart(value);
+    return JSIConverter<std::shared_ptr<margelo::nitro::networking::HybridResponseSpecSwift>>::toJSI(runtime, hybridSpec);
+  }
+
+  bool JSIConverter<::ReactNitroNetworking::HybridResponseSpec_cxx>::canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    return JSIConverter<std::shared_ptr<margelo::nitro::networking::HybridResponseSpecSwift>>::canConvert(runtime, value);
+  }
+
+} // namespace margelo::nitro

package/nitrogen/generated/apple/c++/HybridWebSocketSpecSwift.cpp

@@ -0,0 +1,111 @@
+///
+/// HybridWebSocketSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/margelo/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include <ReactNitroNetworking/private/HybridWebSocketSpecSwift.hpp>
+#include <NitroModules/SwiftConverter.hpp>
+#include <NitroModules/SwiftResult.hpp>
+#include <optional>
+
+namespace margelo::nitro::networking {
+
+  std::string HybridWebSocketSpecSwift::toString() {
+    return SwiftConverter<std::string, swift::String>::fromSwift(_swiftPart.toString());
+  }
+
+  // Properties
+
+  // Methods
+
+  Promise<void> HybridWebSocketSpecSwift::send(const ::ReactNitroNetworking::Variant_ArrayBuffer_String_cxx& data) {
+    auto __result = withCxxResult<Promise<void>>([&](void* __outResult) {
+      return _swiftPart.send(data, __outResult);
+    });
+    if (__result.hasError()) [[unlikely]] {
+      std::rethrow_exception(__result.error());
+    }
+    return std::move(__result.value());
+  }
+
+  void HybridWebSocketSpecSwift::close() {
+    auto __result = _swiftPart.close();
+    if (__result.hasError()) [[unlikely]] {
+      std::rethrow_exception(__result.error());
+    }
+  }
+
+  ::ReactNitroNetworking::ListenerSubscription HybridWebSocketSpecSwift::addOnOpenedListener(const Callback<void()>& listener) {
+    auto __result = ([&](const void* listener) {
+      return withSwiftResult<::ReactNitroNetworking::ListenerSubscription>([&](void* __outResult) {
+        return _swiftPart.addOnOpenedListener(listener, __outResult);
+      });
+    })(std::addressof(listener));
+    if (__result.hasError()) [[unlikely]] {
+      std::rethrow_exception(__result.error());
+    }
+    return std::move(__result.value());
+  }
+
+  ::ReactNitroNetworking::ListenerSubscription HybridWebSocketSpecSwift::addOnMessageReceivedListener(const Callback<void(const ::ReactNitroNetworking::Variant_ArrayBuffer_String_cxx&)>& listener) {
+    auto __result = ([&](const void* listener) {
+      return withSwiftResult<::ReactNitroNetworking::ListenerSubscription>([&](void* __outResult) {
+        return _swiftPart.addOnMessageReceivedListener(listener, __outResult);
+      });
+    })(std::addressof(listener));
+    if (__result.hasError()) [[unlikely]] {
+      std::rethrow_exception(__result.error());
+    }
+    return std::move(__result.value());
+  }
+
+  ::ReactNitroNetworking::ListenerSubscription HybridWebSocketSpecSwift::addOnClosedListener(const Callback<void()>& listener) {
+    auto __result = ([&](const void* listener) {
+      return withSwiftResult<::ReactNitroNetworking::ListenerSubscription>([&](void* __outResult) {
+        return _swiftPart.addOnClosedListener(listener, __outResult);
+      });
+    })(std::addressof(listener));
+    if (__result.hasError()) [[unlikely]] {
+      std::rethrow_exception(__result.error());
+    }
+    return std::move(__result.value());
+  }
+
+  ::ReactNitroNetworking::ListenerSubscription HybridWebSocketSpecSwift::addOnErrorListener(const Callback<void(const std::exception_ptr&)>& listener) {
+    auto __result = ([&](const void* listener) {
+      return withSwiftResult<::ReactNitroNetworking::ListenerSubscription>([&](void* __outResult) {
+        return _swiftPart.addOnErrorListener(listener, __outResult);
+      });
+    })(std::addressof(listener));
+    if (__result.hasError()) [[unlikely]] {
+      std::rethrow_exception(__result.error());
+    }
+    return std::move(__result.value());
+  }
+
+  // Constructor
+
+  ::ReactNitroNetworking::HybridWebSocketSpec_cxx HybridWebSocketSpecSwift::constructor(const swift::String& url) {
+    auto __result = ::ReactNitroNetworking::HybridWebSocketSpec_cxx::constructor(url);
+    if (__result.hasError()) [[unlikely]] {
+      std::rethrow_exception(__result.error());
+    }
+    return ::ReactNitroNetworking::HybridWebSocketSpec_cxx::fromUnsafe(__result.value());
+  }
+
+  const std::shared_ptr<const HybridClass>& HybridWebSocketSpecSwift::Class::get() {
+    static const auto hybridClass = HybridClass::create<Class>([](HybridClass& clazz) {
+      clazz.registerHybridMethod("send", &HybridWebSocketSpecSwift::send);
+      clazz.registerHybridMethod("close", &HybridWebSocketSpecSwift::close);
+      clazz.registerHybridMethod("addOnOpenedListener", &HybridWebSocketSpecSwift::addOnOpenedListener);
+      clazz.registerHybridMethod("addOnMessageReceivedListener", &HybridWebSocketSpecSwift::addOnMessageReceivedListener);
+      clazz.registerHybridMethod("addOnClosedListener", &HybridWebSocketSpecSwift::addOnClosedListener);
+      clazz.registerHybridMethod("addOnErrorListener", &HybridWebSocketSpecSwift::addOnErrorListener);
+      clazz.registerHybridConstructor(&HybridWebSocketSpecSwift::constructor);
+    });
+    return hybridClass;
+  }
+
+} // namespace margelo::nitro::networking