@onekeyfe/react-native-range-downloader 3.0.39

package/lib/module/ReactNativeRangeDownloader.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=ReactNativeRangeDownloader.nitro.js.map

package/lib/module/ReactNativeRangeDownloader.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["ReactNativeRangeDownloader.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+const ReactNativeRangeDownloaderHybridObject = NitroModules.createHybridObject('ReactNativeRangeDownloader');
+export const ReactNativeRangeDownloader = ReactNativeRangeDownloaderHybridObject;
+
+// Closed set of download channels (design decision 10.1). The native side builds the
+// background session identifier as `so.onekey.rangedownloader.bg.<channel>`. New channels
+// must be added here (review-visible), preventing consumers from passing typo'd strings.
+export const RangeDownloadChannel = {
+  Bundle: 'bundle',
+  Apk: 'apk',
+  Chart: 'chart'
+};
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","ReactNativeRangeDownloaderHybridObject","createHybridObject","ReactNativeRangeDownloader","RangeDownloadChannel","Bundle","Apk","Chart"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD,MAAMC,sCAAsC,GAC1CD,YAAY,CAACE,kBAAkB,CAC7B,4BACF,CAAC;AAEH,OAAO,MAAMC,0BAA0B,GAAGF,sCAAsC;;AAEhF;AACA;AACA;AACA,OAAO,MAAMG,oBAAoB,GAAG;EAClCC,MAAM,EAAE,QAAQ;EAChBC,GAAG,EAAE,KAAK;EACVC,KAAK,EAAE;AACT,CAAU","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/ReactNativeRangeDownloader.nitro.d.ts

@@ -0,0 +1,35 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+export type DownloadChannel = 'bundle' | 'apk' | 'chart';
+export interface RangeDownloadParams {
+    channel: DownloadChannel;
+    taskId: string;
+    url: string;
+    destFilePath: string;
+    expectedSha256?: string;
+    segmentCount?: number;
+    minConcurrentBytes?: number;
+}
+export type RangeDownloadOutcome = 'completed' | 'fallback';
+export interface RangeDownloadResult {
+    outcome: RangeDownloadOutcome;
+    filePath: string;
+    fallbackReason?: string;
+}
+export interface RangeDownloadEvent {
+    channel: DownloadChannel;
+    taskId: string;
+    type: string;
+    progress: number;
+    message: string;
+}
+export interface ReactNativeRangeDownloader extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    download(params: RangeDownloadParams): Promise<RangeDownloadResult>;
+    discardArtifacts(channel: DownloadChannel, taskId: string, destFilePath: string): Promise<void>;
+    addDownloadListener(callback: (event: RangeDownloadEvent) => void): number;
+    removeDownloadListener(id: number): void;
+    getDownloadsDir(): string;
+}
+//# sourceMappingURL=ReactNativeRangeDownloader.nitro.d.ts.map

package/lib/typescript/src/ReactNativeRangeDownloader.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactNativeRangeDownloader.nitro.d.ts","sourceRoot":"","sources":["../../../src/ReactNativeRangeDownloader.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAM/D,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,KAAK,GAAG,OAAO,CAAC;AAEzD,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,eAAe,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,MAAM,oBAAoB,GAC5B,WAAW,GACX,UAAU,CAAC;AAEf,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,oBAAoB,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,eAAe,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,0BACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IAIzD,QAAQ,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAIpE,gBAAgB,CACd,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAAC;IAGjB,mBAAmB,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAAG,MAAM,CAAC;IAC3E,sBAAsB,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;IAKzC,eAAe,IAAI,MAAM,CAAC;CAC3B"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,9 @@
+import type { ReactNativeRangeDownloader as ReactNativeRangeDownloaderType } from './ReactNativeRangeDownloader.nitro';
+export declare const ReactNativeRangeDownloader: ReactNativeRangeDownloaderType;
+export declare const RangeDownloadChannel: {
+    readonly Bundle: "bundle";
+    readonly Apk: "apk";
+    readonly Chart: "chart";
+};
+export type * from './ReactNativeRangeDownloader.nitro';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,0BAA0B,IAAI,8BAA8B,EAAE,MAAM,oCAAoC,CAAC;AAOvH,eAAO,MAAM,0BAA0B,gCAAyC,CAAC;AAKjF,eAAO,MAAM,oBAAoB;;;;CAIvB,CAAC;AAEX,mBAAmB,oCAAoC,CAAC"}

package/nitro.json

@@ -0,0 +1,17 @@
+{
+  "cxxNamespace": ["reactnativerangedownloader"],
+  "ios": {
+    "iosModuleName": "ReactNativeRangeDownloader"
+  },
+  "android": {
+    "androidNamespace": ["reactnativerangedownloader"],
+    "androidCxxLibName": "reactnativerangedownloader"
+  },
+  "autolinking": {
+    "ReactNativeRangeDownloader": {
+      "swift": "ReactNativeRangeDownloader",
+      "kotlin": "ReactNativeRangeDownloader"
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}

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

@@ -0,0 +1,62 @@
+///
+/// JDownloadChannel.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "DownloadChannel.hpp"
+
+namespace margelo::nitro::reactnativerangedownloader {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "DownloadChannel" and the the Kotlin enum "DownloadChannel".
+   */
+  struct JDownloadChannel final: public jni::JavaClass<JDownloadChannel> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativerangedownloader/DownloadChannel;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum DownloadChannel.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    DownloadChannel toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<DownloadChannel>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JDownloadChannel> fromCpp(DownloadChannel value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldBUNDLE = clazz->getStaticField<JDownloadChannel>("BUNDLE");
+      static const auto fieldAPK = clazz->getStaticField<JDownloadChannel>("APK");
+      static const auto fieldCHART = clazz->getStaticField<JDownloadChannel>("CHART");
+      
+      switch (value) {
+        case DownloadChannel::BUNDLE:
+          return clazz->getStaticFieldValue(fieldBUNDLE);
+        case DownloadChannel::APK:
+          return clazz->getStaticFieldValue(fieldAPK);
+        case DownloadChannel::CHART:
+          return clazz->getStaticFieldValue(fieldCHART);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::reactnativerangedownloader

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

@@ -0,0 +1,80 @@
+///
+/// JFunc_void_RangeDownloadEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include <functional>
+
+#include "RangeDownloadEvent.hpp"
+#include <functional>
+#include <NitroModules/JNICallable.hpp>
+#include "JRangeDownloadEvent.hpp"
+#include "DownloadChannel.hpp"
+#include "JDownloadChannel.hpp"
+#include <string>
+
+namespace margelo::nitro::reactnativerangedownloader {
+
+  using namespace facebook;
+
+  /**
+   * Represents the Java/Kotlin callback `(event: RangeDownloadEvent) -> Unit`.
+   * This can be passed around between C++ and Java/Kotlin.
+   */
+  struct JFunc_void_RangeDownloadEvent: public jni::JavaClass<JFunc_void_RangeDownloadEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativerangedownloader/Func_void_RangeDownloadEvent;";
+
+  public:
+    /**
+     * Invokes the function this `JFunc_void_RangeDownloadEvent` instance holds through JNI.
+     */
+    void invoke(const RangeDownloadEvent& event) const {
+      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRangeDownloadEvent> /* event */)>("invoke");
+      method(self(), JRangeDownloadEvent::fromCpp(event));
+    }
+  };
+
+  /**
+   * An implementation of Func_void_RangeDownloadEvent that is backed by a C++ implementation (using `std::function<...>`)
+   */
+  class JFunc_void_RangeDownloadEvent_cxx final: public jni::HybridClass<JFunc_void_RangeDownloadEvent_cxx, JFunc_void_RangeDownloadEvent> {
+  public:
+    static jni::local_ref<JFunc_void_RangeDownloadEvent::javaobject> fromCpp(const std::function<void(const RangeDownloadEvent& /* event */)>& func) {
+      return JFunc_void_RangeDownloadEvent_cxx::newObjectCxxArgs(func);
+    }
+
+  public:
+    /**
+     * Invokes the C++ `std::function<...>` this `JFunc_void_RangeDownloadEvent_cxx` instance holds.
+     */
+    void invoke_cxx(jni::alias_ref<JRangeDownloadEvent> event) {
+      _func(event->toCpp());
+    }
+
+  public:
+    [[nodiscard]]
+    inline const std::function<void(const RangeDownloadEvent& /* event */)>& getFunction() const {
+      return _func;
+    }
+
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativerangedownloader/Func_void_RangeDownloadEvent_cxx;";
+    static void registerNatives() {
+      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_RangeDownloadEvent_cxx::invoke_cxx)});
+    }
+
+  private:
+    explicit JFunc_void_RangeDownloadEvent_cxx(const std::function<void(const RangeDownloadEvent& /* event */)>& func): _func(func) { }
+
+  private:
+    friend HybridBase;
+    std::function<void(const RangeDownloadEvent& /* event */)> _func;
+  };
+
+} // namespace margelo::nitro::reactnativerangedownloader

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

@@ -0,0 +1,117 @@
+///
+/// JHybridReactNativeRangeDownloaderSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#include "JHybridReactNativeRangeDownloaderSpec.hpp"
+
+// Forward declaration of `RangeDownloadResult` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadResult; }
+// Forward declaration of `RangeDownloadOutcome` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { enum class RangeDownloadOutcome; }
+// Forward declaration of `RangeDownloadParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadParams; }
+// Forward declaration of `DownloadChannel` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { enum class DownloadChannel; }
+// Forward declaration of `RangeDownloadEvent` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadEvent; }
+
+#include "RangeDownloadResult.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/JPromise.hpp>
+#include "JRangeDownloadResult.hpp"
+#include "RangeDownloadOutcome.hpp"
+#include "JRangeDownloadOutcome.hpp"
+#include <string>
+#include <optional>
+#include "RangeDownloadParams.hpp"
+#include "JRangeDownloadParams.hpp"
+#include "DownloadChannel.hpp"
+#include "JDownloadChannel.hpp"
+#include "RangeDownloadEvent.hpp"
+#include <functional>
+#include "JFunc_void_RangeDownloadEvent.hpp"
+#include <NitroModules/JNICallable.hpp>
+#include "JRangeDownloadEvent.hpp"
+
+namespace margelo::nitro::reactnativerangedownloader {
+
+  jni::local_ref<JHybridReactNativeRangeDownloaderSpec::jhybriddata> JHybridReactNativeRangeDownloaderSpec::initHybrid(jni::alias_ref<jhybridobject> jThis) {
+    return makeCxxInstance(jThis);
+  }
+
+  void JHybridReactNativeRangeDownloaderSpec::registerNatives() {
+    registerHybrid({
+      makeNativeMethod("initHybrid", JHybridReactNativeRangeDownloaderSpec::initHybrid),
+    });
+  }
+
+  size_t JHybridReactNativeRangeDownloaderSpec::getExternalMemorySize() noexcept {
+    static const auto method = javaClassStatic()->getMethod<jlong()>("getMemorySize");
+    return method(_javaPart);
+  }
+
+  void JHybridReactNativeRangeDownloaderSpec::dispose() noexcept {
+    static const auto method = javaClassStatic()->getMethod<void()>("dispose");
+    method(_javaPart);
+  }
+
+  std::string JHybridReactNativeRangeDownloaderSpec::toString() {
+    static const auto method = javaClassStatic()->getMethod<jni::JString()>("toString");
+    auto javaString = method(_javaPart);
+    return javaString->toStdString();
+  }
+
+  // Properties
+  
+
+  // Methods
+  std::shared_ptr<Promise<RangeDownloadResult>> JHybridReactNativeRangeDownloaderSpec::download(const RangeDownloadParams& params) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JRangeDownloadParams> /* params */)>("download");
+    auto __result = method(_javaPart, JRangeDownloadParams::fromCpp(params));
+    return [&]() {
+      auto __promise = Promise<RangeDownloadResult>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        auto __result = jni::static_ref_cast<JRangeDownloadResult>(__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>> JHybridReactNativeRangeDownloaderSpec::discardArtifacts(DownloadChannel channel, const std::string& taskId, const std::string& destFilePath) {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<JPromise::javaobject>(jni::alias_ref<JDownloadChannel> /* channel */, jni::alias_ref<jni::JString> /* taskId */, jni::alias_ref<jni::JString> /* destFilePath */)>("discardArtifacts");
+    auto __result = method(_javaPart, JDownloadChannel::fromCpp(channel), jni::make_jstring(taskId), jni::make_jstring(destFilePath));
+    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;
+    }();
+  }
+  double JHybridReactNativeRangeDownloaderSpec::addDownloadListener(const std::function<void(const RangeDownloadEvent& /* event */)>& callback) {
+    static const auto method = javaClassStatic()->getMethod<double(jni::alias_ref<JFunc_void_RangeDownloadEvent::javaobject> /* callback */)>("addDownloadListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_RangeDownloadEvent_cxx::fromCpp(callback));
+    return __result;
+  }
+  void JHybridReactNativeRangeDownloaderSpec::removeDownloadListener(double id) {
+    static const auto method = javaClassStatic()->getMethod<void(double /* id */)>("removeDownloadListener");
+    method(_javaPart, id);
+  }
+  std::string JHybridReactNativeRangeDownloaderSpec::getDownloadsDir() {
+    static const auto method = javaClassStatic()->getMethod<jni::local_ref<jni::JString>()>("getDownloadsDir");
+    auto __result = method(_javaPart);
+    return __result->toStdString();
+  }
+
+} // namespace margelo::nitro::reactnativerangedownloader

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

@@ -0,0 +1,69 @@
+///
+/// HybridReactNativeRangeDownloaderSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <NitroModules/JHybridObject.hpp>
+#include <fbjni/fbjni.h>
+#include "HybridReactNativeRangeDownloaderSpec.hpp"
+
+
+
+
+namespace margelo::nitro::reactnativerangedownloader {
+
+  using namespace facebook;
+
+  class JHybridReactNativeRangeDownloaderSpec: public jni::HybridClass<JHybridReactNativeRangeDownloaderSpec, JHybridObject>,
+                                               public virtual HybridReactNativeRangeDownloaderSpec {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativerangedownloader/HybridReactNativeRangeDownloaderSpec;";
+    static jni::local_ref<jhybriddata> initHybrid(jni::alias_ref<jhybridobject> jThis);
+    static void registerNatives();
+
+  protected:
+    // C++ constructor (called from Java via `initHybrid()`)
+    explicit JHybridReactNativeRangeDownloaderSpec(jni::alias_ref<jhybridobject> jThis) :
+      HybridObject(HybridReactNativeRangeDownloaderSpec::TAG),
+      HybridBase(jThis),
+      _javaPart(jni::make_global(jThis)) {}
+
+  public:
+    ~JHybridReactNativeRangeDownloaderSpec() 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;
+    std::string toString() override;
+
+  public:
+    inline const jni::global_ref<JHybridReactNativeRangeDownloaderSpec::javaobject>& getJavaPart() const noexcept {
+      return _javaPart;
+    }
+
+  public:
+    // Properties
+    
+
+  public:
+    // Methods
+    std::shared_ptr<Promise<RangeDownloadResult>> download(const RangeDownloadParams& params) override;
+    std::shared_ptr<Promise<void>> discardArtifacts(DownloadChannel channel, const std::string& taskId, const std::string& destFilePath) override;
+    double addDownloadListener(const std::function<void(const RangeDownloadEvent& /* event */)>& callback) override;
+    void removeDownloadListener(double id) override;
+    std::string getDownloadsDir() override;
+
+  private:
+    friend HybridBase;
+    using HybridBase::HybridBase;
+    jni::global_ref<JHybridReactNativeRangeDownloaderSpec::javaobject> _javaPart;
+  };
+
+} // namespace margelo::nitro::reactnativerangedownloader

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

@@ -0,0 +1,75 @@
+///
+/// JRangeDownloadEvent.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "RangeDownloadEvent.hpp"
+
+#include "DownloadChannel.hpp"
+#include "JDownloadChannel.hpp"
+#include <string>
+
+namespace margelo::nitro::reactnativerangedownloader {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "RangeDownloadEvent" and the the Kotlin data class "RangeDownloadEvent".
+   */
+  struct JRangeDownloadEvent final: public jni::JavaClass<JRangeDownloadEvent> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativerangedownloader/RangeDownloadEvent;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct RangeDownloadEvent by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RangeDownloadEvent toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldChannel = clazz->getField<JDownloadChannel>("channel");
+      jni::local_ref<JDownloadChannel> channel = this->getFieldValue(fieldChannel);
+      static const auto fieldTaskId = clazz->getField<jni::JString>("taskId");
+      jni::local_ref<jni::JString> taskId = this->getFieldValue(fieldTaskId);
+      static const auto fieldType = clazz->getField<jni::JString>("type");
+      jni::local_ref<jni::JString> type = this->getFieldValue(fieldType);
+      static const auto fieldProgress = clazz->getField<double>("progress");
+      double progress = this->getFieldValue(fieldProgress);
+      static const auto fieldMessage = clazz->getField<jni::JString>("message");
+      jni::local_ref<jni::JString> message = this->getFieldValue(fieldMessage);
+      return RangeDownloadEvent(
+        channel->toCpp(),
+        taskId->toStdString(),
+        type->toStdString(),
+        progress,
+        message->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<JRangeDownloadEvent::javaobject> fromCpp(const RangeDownloadEvent& value) {
+      using JSignature = JRangeDownloadEvent(jni::alias_ref<JDownloadChannel>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, double, jni::alias_ref<jni::JString>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JDownloadChannel::fromCpp(value.channel),
+        jni::make_jstring(value.taskId),
+        jni::make_jstring(value.type),
+        value.progress,
+        jni::make_jstring(value.message)
+      );
+    }
+  };
+
+} // namespace margelo::nitro::reactnativerangedownloader

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

@@ -0,0 +1,59 @@
+///
+/// JRangeDownloadOutcome.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "RangeDownloadOutcome.hpp"
+
+namespace margelo::nitro::reactnativerangedownloader {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "RangeDownloadOutcome" and the the Kotlin enum "RangeDownloadOutcome".
+   */
+  struct JRangeDownloadOutcome final: public jni::JavaClass<JRangeDownloadOutcome> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativerangedownloader/RangeDownloadOutcome;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum RangeDownloadOutcome.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RangeDownloadOutcome toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<RangeDownloadOutcome>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JRangeDownloadOutcome> fromCpp(RangeDownloadOutcome value) {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldCOMPLETED = clazz->getStaticField<JRangeDownloadOutcome>("COMPLETED");
+      static const auto fieldFALLBACK = clazz->getStaticField<JRangeDownloadOutcome>("FALLBACK");
+      
+      switch (value) {
+        case RangeDownloadOutcome::COMPLETED:
+          return clazz->getStaticFieldValue(fieldCOMPLETED);
+        case RangeDownloadOutcome::FALLBACK:
+          return clazz->getStaticFieldValue(fieldFALLBACK);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::reactnativerangedownloader

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

@@ -0,0 +1,84 @@
+///
+/// JRangeDownloadParams.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "RangeDownloadParams.hpp"
+
+#include "DownloadChannel.hpp"
+#include "JDownloadChannel.hpp"
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::reactnativerangedownloader {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "RangeDownloadParams" and the the Kotlin data class "RangeDownloadParams".
+   */
+  struct JRangeDownloadParams final: public jni::JavaClass<JRangeDownloadParams> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/reactnativerangedownloader/RangeDownloadParams;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct RangeDownloadParams by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    RangeDownloadParams toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldChannel = clazz->getField<JDownloadChannel>("channel");
+      jni::local_ref<JDownloadChannel> channel = this->getFieldValue(fieldChannel);
+      static const auto fieldTaskId = clazz->getField<jni::JString>("taskId");
+      jni::local_ref<jni::JString> taskId = this->getFieldValue(fieldTaskId);
+      static const auto fieldUrl = clazz->getField<jni::JString>("url");
+      jni::local_ref<jni::JString> url = this->getFieldValue(fieldUrl);
+      static const auto fieldDestFilePath = clazz->getField<jni::JString>("destFilePath");
+      jni::local_ref<jni::JString> destFilePath = this->getFieldValue(fieldDestFilePath);
+      static const auto fieldExpectedSha256 = clazz->getField<jni::JString>("expectedSha256");
+      jni::local_ref<jni::JString> expectedSha256 = this->getFieldValue(fieldExpectedSha256);
+      static const auto fieldSegmentCount = clazz->getField<jni::JDouble>("segmentCount");
+      jni::local_ref<jni::JDouble> segmentCount = this->getFieldValue(fieldSegmentCount);
+      static const auto fieldMinConcurrentBytes = clazz->getField<jni::JDouble>("minConcurrentBytes");
+      jni::local_ref<jni::JDouble> minConcurrentBytes = this->getFieldValue(fieldMinConcurrentBytes);
+      return RangeDownloadParams(
+        channel->toCpp(),
+        taskId->toStdString(),
+        url->toStdString(),
+        destFilePath->toStdString(),
+        expectedSha256 != nullptr ? std::make_optional(expectedSha256->toStdString()) : std::nullopt,
+        segmentCount != nullptr ? std::make_optional(segmentCount->value()) : std::nullopt,
+        minConcurrentBytes != nullptr ? std::make_optional(minConcurrentBytes->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<JRangeDownloadParams::javaobject> fromCpp(const RangeDownloadParams& value) {
+      using JSignature = JRangeDownloadParams(jni::alias_ref<JDownloadChannel>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JDouble>, jni::alias_ref<jni::JDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JDownloadChannel::fromCpp(value.channel),
+        jni::make_jstring(value.taskId),
+        jni::make_jstring(value.url),
+        jni::make_jstring(value.destFilePath),
+        value.expectedSha256.has_value() ? jni::make_jstring(value.expectedSha256.value()) : nullptr,
+        value.segmentCount.has_value() ? jni::JDouble::valueOf(value.segmentCount.value()) : nullptr,
+        value.minConcurrentBytes.has_value() ? jni::JDouble::valueOf(value.minConcurrentBytes.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::reactnativerangedownloader