react-native-nitro-fetch 0.1.1

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

@@ -0,0 +1,96 @@
+///
+/// JHybridNitroFetchClientSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridNitroFetchClientSpec.hpp"
+
+// Forward declaration of `NitroResponse` to properly resolve imports.
+namespace margelo::nitro::nitrofetch { struct NitroResponse; }
+// Forward declaration of `NitroHeader` to properly resolve imports.
+namespace margelo::nitro::nitrofetch { struct NitroHeader; }
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+// Forward declaration of `NitroRequest` to properly resolve imports.
+namespace margelo::nitro::nitrofetch { struct NitroRequest; }
+// Forward declaration of `NitroRequestMethod` to properly resolve imports.
+namespace margelo::nitro::nitrofetch { enum class NitroRequestMethod; }
+
+#include "NitroResponse.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JNitroResponse.hpp"
+#include <string>
+#include "NitroHeader.hpp"
+#include <vector>
+#include "JNitroHeader.hpp"
+#include <optional>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <NitroModules/JUnit.hpp>
+#include "NitroRequest.hpp"
+#include "JNitroRequest.hpp"
+#include "NitroRequestMethod.hpp"
+#include "JNitroRequestMethod.hpp"
+
+namespace margelo::nitro::nitrofetch {
+
+  jni::local_ref<JHybridNitroFetchClientSpec::jhybriddata> JHybridNitroFetchClientSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridNitroFetchClientSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNitroFetchClientSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridNitroFetchClientSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridNitroFetchClientSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<NitroResponse>> JHybridNitroFetchClientSpec::request(const NitroRequest& req) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JNitroRequest> /* req */)>("request");
+    auto __result = method(_javaPart, JNitroRequest::fromCpp(req));
+    return [&]() {
+      auto __promise = Promise<NitroResponse>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JNitroResponse>(__boxedResult);
+        __promise->resolve(__result->toCpp());
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+  std::shared_ptr<Promise<void>> JHybridNitroFetchClientSpec::prefetch(const NitroRequest& req) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JNitroRequest> /* req */)>("prefetch");
+    auto __result = method(_javaPart, JNitroRequest::fromCpp(req));
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& /* unit */) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
+
+} // namespace margelo::nitro::nitrofetch

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

@@ -0,0 +1,65 @@
+///
+/// HybridNitroFetchClientSpec.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 <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridNitroFetchClientSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitrofetch {
+
+  using namespace facebook;
+
+  class JHybridNitroFetchClientSpec: public jni::HybridClass<JHybridNitroFetchClientSpec, JHybridObject>,
+                                     public virtual HybridNitroFetchClientSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrofetch/HybridNitroFetchClientSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridNitroFetchClientSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridNitroFetchClientSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridNitroFetchClientSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+
+  public:
+    inline const jni::global_ref<JHybridNitroFetchClientSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<NitroResponse>> request(const NitroRequest& req) override;
+    std::shared_ptr<Promise<void>> prefetch(const NitroRequest& req) override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridNitroFetchClientSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitrofetch

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

@@ -0,0 +1,49 @@
+///
+/// JHybridNitroFetchSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "JHybridNitroFetchSpec.hpp"
+
+// Forward declaration of `HybridNitroFetchClientSpec` to properly resolve imports.
+namespace margelo::nitro::nitrofetch { class HybridNitroFetchClientSpec; }
+
+#include <memory>
+#include "HybridNitroFetchClientSpec.hpp"
+#include "JHybridNitroFetchClientSpec.hpp"
+
+namespace margelo::nitro::nitrofetch {
+
+  jni::local_ref<JHybridNitroFetchSpec::jhybriddata> JHybridNitroFetchSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridNitroFetchSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridNitroFetchSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridNitroFetchSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridNitroFetchSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<HybridNitroFetchClientSpec> JHybridNitroFetchSpec::createClient() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JHybridNitroFetchClientSpec::javaobject>()>("createClient");
+    auto __result = method(_javaPart);
+    return __result->cthis()->shared_cast<JHybridNitroFetchClientSpec>();
+  }
+
+} // namespace margelo::nitro::nitrofetch

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

@@ -0,0 +1,64 @@
+///
+/// HybridNitroFetchSpec.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 <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridNitroFetchSpec.hpp"
+
+
+
+
+namespace margelo::nitro::nitrofetch {
+
+  using namespace facebook;
+
+  class JHybridNitroFetchSpec: public jni::HybridClass<JHybridNitroFetchSpec, JHybridObject>,
+                               public virtual HybridNitroFetchSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrofetch/HybridNitroFetchSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridNitroFetchSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridNitroFetchSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridNitroFetchSpec() override {
+      // Hermes GC can destroy JS objects on a non-JNI Thread.
+      jni::ThreadScope::WithClassLoader([&] { _javaPart.reset(); });
+    }
+
+  public:
+    size_t getExternalMemorySize() noexcept override;
+    void dispose() noexcept override;
+
+  public:
+    inline const jni::global_ref<JHybridNitroFetchSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<HybridNitroFetchClientSpec> createClient() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridNitroFetchSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::nitrofetch

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

@@ -0,0 +1,57 @@
+///
+/// JNitroHeader.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 <fbjni/fbjni.h>
+#include "NitroHeader.hpp"
+
+#include <string>
+
+namespace margelo::nitro::nitrofetch {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "NitroHeader" and the the Kotlin data class "NitroHeader".
+   */
+  struct JNitroHeader final: public jni::JavaClass<JNitroHeader> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrofetch/NitroHeader;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct NitroHeader by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    NitroHeader toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldKey = clazz->getField<jni::JString>("key");
+      jni::local_ref<jni::JString> key = this->getFieldValue(fieldKey);
+      static const auto fieldValue = clazz->getField<jni::JString>("value");
+      jni::local_ref<jni::JString> value = this->getFieldValue(fieldValue);
+      return NitroHeader(
+        key->toStdString(),
+        value->toStdString()
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JNitroHeader::javaobject> fromCpp(const NitroHeader& value) {
+      return newInstance(
+        jni::make_jstring(value.key),
+        jni::make_jstring(value.value)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrofetch

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

@@ -0,0 +1,103 @@
+///
+/// JNitroRequest.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 <fbjni/fbjni.h>
+#include "NitroRequest.hpp"
+
+#include "JNitroHeader.hpp"
+#include "JNitroRequestMethod.hpp"
+#include "NitroHeader.hpp"
+#include "NitroRequestMethod.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <NitroModules/JUnit.hpp>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::nitrofetch {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "NitroRequest" and the the Kotlin data class "NitroRequest".
+   */
+  struct JNitroRequest final: public jni::JavaClass<JNitroRequest> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrofetch/NitroRequest;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct NitroRequest by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    NitroRequest toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldUrl = clazz->getField<jni::JString>("url");
+      jni::local_ref<jni::JString> url = this->getFieldValue(fieldUrl);
+      static const auto fieldMethod = clazz->getField<JNitroRequestMethod>("method");
+      jni::local_ref<JNitroRequestMethod> method = this->getFieldValue(fieldMethod);
+      static const auto fieldHeaders = clazz->getField<jni::JArrayClass<JNitroHeader>>("headers");
+      jni::local_ref<jni::JArrayClass<JNitroHeader>> headers = this->getFieldValue(fieldHeaders);
+      static const auto fieldBodyString = clazz->getField<jni::JString>("bodyString");
+      jni::local_ref<jni::JString> bodyString = this->getFieldValue(fieldBodyString);
+      static const auto fieldBodyBytes = clazz->getField<JArrayBuffer::javaobject>("bodyBytes");
+      jni::local_ref<JArrayBuffer::javaobject> bodyBytes = this->getFieldValue(fieldBodyBytes);
+      static const auto fieldTimeoutMs = clazz->getField<jni::JDouble>("timeoutMs");
+      jni::local_ref<jni::JDouble> timeoutMs = this->getFieldValue(fieldTimeoutMs);
+      static const auto fieldFollowRedirects = clazz->getField<jni::JBoolean>("followRedirects");
+      jni::local_ref<jni::JBoolean> followRedirects = this->getFieldValue(fieldFollowRedirects);
+      return NitroRequest(
+        url->toStdString(),
+        method != nullptr ? std::make_optional(method->toCpp()) : std::nullopt,
+        headers != nullptr ? std::make_optional([&]() {
+          size_t __size = headers->size();
+          std::vector<NitroHeader> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = headers->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }()) : std::nullopt,
+        bodyString != nullptr ? std::make_optional(bodyString->toStdString()) : std::nullopt,
+        bodyBytes != nullptr ? std::make_optional(bodyBytes->cthis()->getArrayBuffer()) : std::nullopt,
+        timeoutMs != nullptr ? std::make_optional(timeoutMs->value()) : std::nullopt,
+        followRedirects != nullptr ? std::make_optional(static_cast<bool>(followRedirects->value())) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JNitroRequest::javaobject> fromCpp(const NitroRequest& value) {
+      return newInstance(
+        jni::make_jstring(value.url),
+        value.method.has_value() ? JNitroRequestMethod::fromCpp(value.method.value()) : nullptr,
+        value.headers.has_value() ? [&]() {
+          size_t __size = value.headers.value().size();
+          jni::local_ref<jni::JArrayClass<JNitroHeader>> __array = jni::JArrayClass<JNitroHeader>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.headers.value()[__i];
+            __array->setElement(__i, *JNitroHeader::fromCpp(__element));
+          }
+          return __array;
+        }() : nullptr,
+        value.bodyString.has_value() ? jni::make_jstring(value.bodyString.value()) : nullptr,
+        value.bodyBytes.has_value() ? JArrayBuffer::wrap(value.bodyBytes.value()) : nullptr,
+        value.timeoutMs.has_value() ? jni::JDouble::valueOf(value.timeoutMs.value()) : nullptr,
+        value.followRedirects.has_value() ? jni::JBoolean::valueOf(value.followRedirects.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrofetch

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

@@ -0,0 +1,74 @@
+///
+/// JNitroRequestMethod.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 <fbjni/fbjni.h>
+#include "NitroRequestMethod.hpp"
+
+namespace margelo::nitro::nitrofetch {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "NitroRequestMethod" and the the Kotlin enum "NitroRequestMethod".
+   */
+  struct JNitroRequestMethod final: public jni::JavaClass<JNitroRequestMethod> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrofetch/NitroRequestMethod;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum NitroRequestMethod.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    NitroRequestMethod toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<NitroRequestMethod>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JNitroRequestMethod> fromCpp(NitroRequestMethod value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldGET = clazz->getStaticField<JNitroRequestMethod>("GET");
+      static const auto fieldHEAD = clazz->getStaticField<JNitroRequestMethod>("HEAD");
+      static const auto fieldPOST = clazz->getStaticField<JNitroRequestMethod>("POST");
+      static const auto fieldPUT = clazz->getStaticField<JNitroRequestMethod>("PUT");
+      static const auto fieldPATCH = clazz->getStaticField<JNitroRequestMethod>("PATCH");
+      static const auto fieldDELETE = clazz->getStaticField<JNitroRequestMethod>("DELETE");
+      static const auto fieldOPTIONS = clazz->getStaticField<JNitroRequestMethod>("OPTIONS");
+      
+      switch (value) {
+        case NitroRequestMethod::GET:
+          return clazz->getStaticFieldValue(fieldGET);
+        case NitroRequestMethod::HEAD:
+          return clazz->getStaticFieldValue(fieldHEAD);
+        case NitroRequestMethod::POST:
+          return clazz->getStaticFieldValue(fieldPOST);
+        case NitroRequestMethod::PUT:
+          return clazz->getStaticFieldValue(fieldPUT);
+        case NitroRequestMethod::PATCH:
+          return clazz->getStaticFieldValue(fieldPATCH);
+        case NitroRequestMethod::DELETE:
+          return clazz->getStaticFieldValue(fieldDELETE);
+        case NitroRequestMethod::OPTIONS:
+          return clazz->getStaticFieldValue(fieldOPTIONS);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::nitrofetch

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

@@ -0,0 +1,105 @@
+///
+/// JNitroResponse.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 <fbjni/fbjni.h>
+#include "NitroResponse.hpp"
+
+#include "JNitroHeader.hpp"
+#include "NitroHeader.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/JArrayBuffer.hpp>
+#include <NitroModules/JUnit.hpp>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::nitrofetch {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "NitroResponse" and the the Kotlin data class "NitroResponse".
+   */
+  struct JNitroResponse final: public jni::JavaClass<JNitroResponse> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/nitrofetch/NitroResponse;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct NitroResponse by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    NitroResponse toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldUrl = clazz->getField<jni::JString>("url");
+      jni::local_ref<jni::JString> url = this->getFieldValue(fieldUrl);
+      static const auto fieldStatus = clazz->getField<double>("status");
+      double status = this->getFieldValue(fieldStatus);
+      static const auto fieldStatusText = clazz->getField<jni::JString>("statusText");
+      jni::local_ref<jni::JString> statusText = this->getFieldValue(fieldStatusText);
+      static const auto fieldOk = clazz->getField<jboolean>("ok");
+      jboolean ok = this->getFieldValue(fieldOk);
+      static const auto fieldRedirected = clazz->getField<jboolean>("redirected");
+      jboolean redirected = this->getFieldValue(fieldRedirected);
+      static const auto fieldHeaders = clazz->getField<jni::JArrayClass<JNitroHeader>>("headers");
+      jni::local_ref<jni::JArrayClass<JNitroHeader>> headers = this->getFieldValue(fieldHeaders);
+      static const auto fieldBodyString = clazz->getField<jni::JString>("bodyString");
+      jni::local_ref<jni::JString> bodyString = this->getFieldValue(fieldBodyString);
+      static const auto fieldBodyBytes = clazz->getField<JArrayBuffer::javaobject>("bodyBytes");
+      jni::local_ref<JArrayBuffer::javaobject> bodyBytes = this->getFieldValue(fieldBodyBytes);
+      return NitroResponse(
+        url->toStdString(),
+        status,
+        statusText->toStdString(),
+        static_cast<bool>(ok),
+        static_cast<bool>(redirected),
+        [&]() {
+          size_t __size = headers->size();
+          std::vector<NitroHeader> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = headers->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(),
+        bodyString != nullptr ? std::make_optional(bodyString->toStdString()) : std::nullopt,
+        bodyBytes != nullptr ? std::make_optional(bodyBytes->cthis()->getArrayBuffer()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JNitroResponse::javaobject> fromCpp(const NitroResponse& value) {
+      return newInstance(
+        jni::make_jstring(value.url),
+        value.status,
+        jni::make_jstring(value.statusText),
+        value.ok,
+        value.redirected,
+        [&]() {
+          size_t __size = value.headers.size();
+          jni::local_ref<jni::JArrayClass<JNitroHeader>> __array = jni::JArrayClass<JNitroHeader>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.headers[__i];
+            __array->setElement(__i, *JNitroHeader::fromCpp(__element));
+          }
+          return __array;
+        }(),
+        value.bodyString.has_value() ? jni::make_jstring(value.bodyString.value()) : nullptr,
+        value.bodyBytes.has_value() ? JArrayBuffer::wrap(value.bodyBytes.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::nitrofetch

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitrofetch/HybridNitroFetchClientSpec.kt

@@ -0,0 +1,56 @@
+///
+/// HybridNitroFetchClientSpec.kt
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+package com.margelo.nitro.nitrofetch
+
+import androidx.annotation.Keep
+import com.facebook.jni.HybridData
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.*
+
+/**
+ * A Kotlin class representing the NitroFetchClient HybridObject.
+ * Implement this abstract class to create Kotlin-based instances of NitroFetchClient.
+ */
+@DoNotStrip
+@Keep
+@Suppress(
+  "KotlinJniMissingFunction", "unused",
+  "RedundantSuppression", "RedundantUnitReturnType", "SimpleRedundantLet",
+  "LocalVariableName", "PropertyName", "PrivatePropertyName", "FunctionName"
+)
+abstract class HybridNitroFetchClientSpec: HybridObject() {
+  @DoNotStrip
+  private var mHybridData: HybridData = initHybrid()
+
+  init {
+    super.updateNative(mHybridData)
+  }
+
+  override fun updateNative(hybridData: HybridData) {
+    mHybridData = hybridData
+    super.updateNative(hybridData)
+  }
+
+  // Properties
+  
+
+  // Methods
+  @DoNotStrip
+  @Keep
+  abstract fun request(req: NitroRequest): Promise<NitroResponse>
+  
+  @DoNotStrip
+  @Keep
+  abstract fun prefetch(req: NitroRequest): Promise<Unit>
+
+  private external fun initHybrid(): HybridData
+
+  companion object {
+    private const val TAG = "HybridNitroFetchClientSpec"
+  }
+}