react-native-nitro-fetch 0.1.7 → 0.2.0

package/nitrogen/generated/ios/NitroFetchAutolinking.swift

@@ -2,19 +2,16 @@
 /// NitroFetchAutolinking.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
+import NitroModules
+
+// TODO: Use empty enums once Swift supports exporting them as namespaces
+//       See: https://github.com/swiftlang/swift/pull/83616
 public final class NitroFetchAutolinking {
   public typealias bridge = margelo.nitro.nitrofetch.bridge.swift
 
-  /**
-   * Creates an instance of a Swift class that implements `HybridNitroFetchSpec`,
-   * and wraps it in a Swift class that can directly interop with C++ (`HybridNitroFetchSpec_cxx`)
-   *
-   * This is generated by Nitrogen and will initialize the class specified
-   * in the `"autolinking"` property of `nitro.json` (in this case, `NitroFetch`).
-   */
   public static func createNitroFetch() -> bridge.std__shared_ptr_HybridNitroFetchSpec_ {
     let hybridObject = NitroFetch()
     return { () -> bridge.std__shared_ptr_HybridNitroFetchSpec_ in
@@ -23,13 +20,10 @@ public final class NitroFetchAutolinking {
     }()
   }
   
-  /**
-   * Creates an instance of a Swift class that implements `HybridNitroFetchClientSpec`,
-   * and wraps it in a Swift class that can directly interop with C++ (`HybridNitroFetchClientSpec_cxx`)
-   *
-   * This is generated by Nitrogen and will initialize the class specified
-   * in the `"autolinking"` property of `nitro.json` (in this case, `NitroFetchClient`).
-   */
+  public static func isNitroFetchRecyclable() -> Bool {
+    return NitroFetch.self is any RecyclableView.Type
+  }
+  
   public static func createNitroFetchClient() -> bridge.std__shared_ptr_HybridNitroFetchClientSpec_ {
     let hybridObject = NitroFetchClient()
     return { () -> bridge.std__shared_ptr_HybridNitroFetchClientSpec_ in
@@ -38,13 +32,10 @@ public final class NitroFetchAutolinking {
     }()
   }
   
-  /**
-   * Creates an instance of a Swift class that implements `HybridNativeStorageSpec`,
-   * and wraps it in a Swift class that can directly interop with C++ (`HybridNativeStorageSpec_cxx`)
-   *
-   * This is generated by Nitrogen and will initialize the class specified
-   * in the `"autolinking"` property of `nitro.json` (in this case, `NativeStorage`).
-   */
+  public static func isNitroFetchClientRecyclable() -> Bool {
+    return NitroFetchClient.self is any RecyclableView.Type
+  }
+  
   public static func createNativeStorage() -> bridge.std__shared_ptr_HybridNativeStorageSpec_ {
     let hybridObject = NativeStorage()
     return { () -> bridge.std__shared_ptr_HybridNativeStorageSpec_ in
@@ -52,4 +43,20 @@ public final class NitroFetchAutolinking {
       return __cxxWrapped.getCxxPart()
     }()
   }
+  
+  public static func isNativeStorageRecyclable() -> Bool {
+    return NativeStorage.self is any RecyclableView.Type
+  }
+  
+  public static func createNitroCronet() -> bridge.std__shared_ptr_HybridNitroCronetSpec_ {
+    let hybridObject = HybridNitroCronet()
+    return { () -> bridge.std__shared_ptr_HybridNitroCronetSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+  
+  public static func isNitroCronetRecyclable() -> Bool {
+    return HybridNitroCronet.self is any RecyclableView.Type
+  }
 }

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

@@ -2,7 +2,7 @@
 /// HybridNativeStorageSpecSwift.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #include "HybridNativeStorageSpecSwift.hpp"

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

@@ -2,7 +2,7 @@
 /// HybridNativeStorageSpecSwift.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -47,9 +47,18 @@ namespace margelo::nitro::nitrofetch {
     inline size_t getExternalMemorySize() noexcept override {
       return _swiftPart.getMemorySize();
     }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridNativeStorageSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
     void dispose() noexcept override {
       _swiftPart.dispose();
     }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
 
   public:
     // Properties

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

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

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

@@ -0,0 +1,85 @@
+///
+/// HybridNitroCronetSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridNitroCronetSpec.hpp"
+
+// Forward declaration of `HybridNitroCronetSpec_cxx` to properly resolve imports.
+namespace NitroFetch { class HybridNitroCronetSpec_cxx; }
+
+// Forward declaration of `HybridUrlRequestBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::nitrofetch { class HybridUrlRequestBuilderSpec; }
+
+#include <memory>
+#include "HybridUrlRequestBuilderSpec.hpp"
+#include <string>
+
+#include "NitroFetch-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitrofetch {
+
+  /**
+   * The C++ part of HybridNitroCronetSpec_cxx.swift.
+   *
+   * HybridNitroCronetSpecSwift (C++) accesses HybridNitroCronetSpec_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, HybridNitroCronetSpec_cxx can directly inherit from the C++ class HybridNitroCronetSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridNitroCronetSpecSwift: public virtual HybridNitroCronetSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridNitroCronetSpecSwift(const NitroFetch::HybridNitroCronetSpec_cxx& swiftPart):
+      HybridObject(HybridNitroCronetSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroFetch::HybridNitroCronetSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridNitroCronetSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline std::shared_ptr<HybridUrlRequestBuilderSpec> newUrlRequestBuilder(const std::string& url) override {
+      auto __result = _swiftPart.newUrlRequestBuilder(url);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    NitroFetch::HybridNitroCronetSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitrofetch

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

@@ -2,7 +2,7 @@
 /// HybridNitroFetchClientSpecSwift.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #include "HybridNitroFetchClientSpecSwift.hpp"

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

@@ -2,7 +2,7 @@
 /// HybridNitroFetchClientSpecSwift.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -20,6 +20,8 @@ namespace margelo::nitro::nitrofetch { struct NitroHeader; }
 namespace margelo::nitro::nitrofetch { struct NitroRequest; }
 // Forward declaration of `NitroRequestMethod` to properly resolve imports.
 namespace margelo::nitro::nitrofetch { enum class NitroRequestMethod; }
+// Forward declaration of `NitroFormDataPart` to properly resolve imports.
+namespace margelo::nitro::nitrofetch { struct NitroFormDataPart; }
 
 #include "NitroResponse.hpp"
 #include <NitroModules/Promise.hpp>
@@ -29,6 +31,7 @@ namespace margelo::nitro::nitrofetch { enum class NitroRequestMethod; }
 #include <optional>
 #include "NitroRequest.hpp"
 #include "NitroRequestMethod.hpp"
+#include "NitroFormDataPart.hpp"
 
 #include "NitroFetch-Swift-Cxx-Umbrella.hpp"
 
@@ -61,9 +64,18 @@ namespace margelo::nitro::nitrofetch {
     inline size_t getExternalMemorySize() noexcept override {
       return _swiftPart.getMemorySize();
     }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridNitroFetchClientSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
     void dispose() noexcept override {
       _swiftPart.dispose();
     }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
 
   public:
     // Properties
@@ -72,7 +84,7 @@ namespace margelo::nitro::nitrofetch {
   public:
     // Methods
     inline std::shared_ptr<Promise<NitroResponse>> request(const NitroRequest& req) override {
-      auto __result = _swiftPart.request(req);
+      auto __result = _swiftPart.request(std::forward<decltype(req)>(req));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -80,7 +92,7 @@ namespace margelo::nitro::nitrofetch {
       return __value;
     }
     inline std::shared_ptr<Promise<void>> prefetch(const NitroRequest& req) override {
-      auto __result = _swiftPart.prefetch(req);
+      auto __result = _swiftPart.prefetch(std::forward<decltype(req)>(req));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -88,13 +100,19 @@ namespace margelo::nitro::nitrofetch {
       return __value;
     }
     inline NitroResponse requestSync(const NitroRequest& req) override {
-      auto __result = _swiftPart.requestSync(req);
+      auto __result = _swiftPart.requestSync(std::forward<decltype(req)>(req));
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline void cancelRequest(const std::string& requestId) override {
+      auto __result = _swiftPart.cancelRequest(requestId);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
 
   private:
     NitroFetch::HybridNitroFetchClientSpec_cxx _swiftPart;

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

@@ -2,7 +2,7 @@
 /// HybridNitroFetchSpecSwift.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #include "HybridNitroFetchSpecSwift.hpp"

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

@@ -2,7 +2,7 @@
 /// HybridNitroFetchSpecSwift.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -49,9 +49,18 @@ namespace margelo::nitro::nitrofetch {
     inline size_t getExternalMemorySize() noexcept override {
       return _swiftPart.getMemorySize();
     }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridNitroFetchSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
     void dispose() noexcept override {
       _swiftPart.dispose();
     }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
 
   public:
     // Properties

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

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

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

@@ -0,0 +1,163 @@
+///
+/// HybridUrlRequestBuilderSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridUrlRequestBuilderSpec.hpp"
+
+// Forward declaration of `HybridUrlRequestBuilderSpec_cxx` to properly resolve imports.
+namespace NitroFetch { class HybridUrlRequestBuilderSpec_cxx; }
+
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
+// Forward declaration of `UrlResponseInfo` to properly resolve imports.
+namespace margelo::nitro::nitrofetch { struct UrlResponseInfo; }
+// Forward declaration of `HttpHeader` to properly resolve imports.
+namespace margelo::nitro::nitrofetch { struct HttpHeader; }
+// Forward declaration of `RequestException` to properly resolve imports.
+namespace margelo::nitro::nitrofetch { struct RequestException; }
+// Forward declaration of `HybridUrlRequestSpec` to properly resolve imports.
+namespace margelo::nitro::nitrofetch { class HybridUrlRequestSpec; }
+
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <variant>
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include "UrlResponseInfo.hpp"
+#include <functional>
+#include <unordered_map>
+#include "HttpHeader.hpp"
+#include <vector>
+#include <optional>
+#include "RequestException.hpp"
+#include <memory>
+#include "HybridUrlRequestSpec.hpp"
+
+#include "NitroFetch-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitrofetch {
+
+  /**
+   * The C++ part of HybridUrlRequestBuilderSpec_cxx.swift.
+   *
+   * HybridUrlRequestBuilderSpecSwift (C++) accesses HybridUrlRequestBuilderSpec_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, HybridUrlRequestBuilderSpec_cxx can directly inherit from the C++ class HybridUrlRequestBuilderSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridUrlRequestBuilderSpecSwift: public virtual HybridUrlRequestBuilderSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridUrlRequestBuilderSpecSwift(const NitroFetch::HybridUrlRequestBuilderSpec_cxx& swiftPart):
+      HybridObject(HybridUrlRequestBuilderSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroFetch::HybridUrlRequestBuilderSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridUrlRequestBuilderSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline void setHttpMethod(const std::string& httpMethod) override {
+      auto __result = _swiftPart.setHttpMethod(httpMethod);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void addHeader(const std::string& name, const std::string& value) override {
+      auto __result = _swiftPart.addHeader(name, value);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void setUploadBody(const std::variant<std::shared_ptr<ArrayBuffer>, std::string>& body) override {
+      auto __result = _swiftPart.setUploadBody(body);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void disableCache() override {
+      auto __result = _swiftPart.disableCache();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onSucceeded(const std::function<void(const UrlResponseInfo& /* info */)>& callback) override {
+      auto __result = _swiftPart.onSucceeded(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onFailed(const std::function<void(const std::optional<UrlResponseInfo>& /* info */, const RequestException& /* error */)>& callback) override {
+      auto __result = _swiftPart.onFailed(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onCanceled(const std::function<void(const std::optional<UrlResponseInfo>& /* info */)>& callback) override {
+      auto __result = _swiftPart.onCanceled(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onRedirectReceived(const std::function<void(const UrlResponseInfo& /* info */, const std::string& /* newLocationUrl */)>& callback) override {
+      auto __result = _swiftPart.onRedirectReceived(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onResponseStarted(const std::function<void(const UrlResponseInfo& /* info */)>& callback) override {
+      auto __result = _swiftPart.onResponseStarted(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void onReadCompleted(const std::function<void(const UrlResponseInfo& /* info */, const std::shared_ptr<ArrayBuffer>& /* byteBuffer */, double /* bytesRead */)>& callback) override {
+      auto __result = _swiftPart.onReadCompleted(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<HybridUrlRequestSpec> build() override {
+      auto __result = _swiftPart.build();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    NitroFetch::HybridUrlRequestBuilderSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitrofetch

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

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

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

@@ -0,0 +1,106 @@
+///
+/// HybridUrlRequestSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridUrlRequestSpec.hpp"
+
+// Forward declaration of `HybridUrlRequestSpec_cxx` to properly resolve imports.
+namespace NitroFetch { class HybridUrlRequestSpec_cxx; }
+
+
+
+
+
+#include "NitroFetch-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::nitrofetch {
+
+  /**
+   * The C++ part of HybridUrlRequestSpec_cxx.swift.
+   *
+   * HybridUrlRequestSpecSwift (C++) accesses HybridUrlRequestSpec_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, HybridUrlRequestSpec_cxx can directly inherit from the C++ class HybridUrlRequestSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridUrlRequestSpecSwift: public virtual HybridUrlRequestSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridUrlRequestSpecSwift(const NitroFetch::HybridUrlRequestSpec_cxx& swiftPart):
+      HybridObject(HybridUrlRequestSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline NitroFetch::HybridUrlRequestSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridUrlRequestSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    inline void start() override {
+      auto __result = _swiftPart.start();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void followRedirect() override {
+      auto __result = _swiftPart.followRedirect();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void read() override {
+      auto __result = _swiftPart.read();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline void cancel() override {
+      auto __result = _swiftPart.cancel();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline bool isDone() override {
+      auto __result = _swiftPart.isDone();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    NitroFetch::HybridUrlRequestSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::nitrofetch

package/nitrogen/generated/ios/swift/Func_void.swift

@@ -2,12 +2,11 @@
 /// Func_void.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 import NitroModules
 
-
 /**
  * Wraps a Swift `() -> Void` as a class.
  * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.

package/nitrogen/generated/ios/swift/Func_void_NitroResponse.swift

@@ -2,12 +2,11 @@
 /// Func_void_NitroResponse.swift
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
+/// Copyright © Marc Rousavy @ Margelo
 ///
 
 import NitroModules
 
-
 /**
  * Wraps a Swift `(_ value: NitroResponse) -> Void` as a class.
  * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.