@onekeyfe/react-native-range-downloader 3.0.80 → 3.0.81-alpha.0

package/nitrogen/generated/ios/swift/HybridReactNativeRangeDownloaderSpec_cxx.swift

@@ -213,4 +213,244 @@ open class HybridReactNativeRangeDownloaderSpec_cxx {
       return bridge.create_Result_std__string_(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func getFirmwareArtifactCapabilities() -> bridge.Result_FirmwareArtifactCapabilities_ {
+    do {
+      let __result = try self.__implementation.getFirmwareArtifactCapabilities()
+      let __resultCpp = __result
+      return bridge.create_Result_FirmwareArtifactCapabilities_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_FirmwareArtifactCapabilities_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func downloadFirmwareArtifact(params: FirmwareArtifactDownloadParams) -> bridge.Result_std__shared_ptr_Promise_FirmwareArtifactReceipt___ {
+    do {
+      let __result = try self.__implementation.downloadFirmwareArtifact(params: params)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_FirmwareArtifactReceipt__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_FirmwareArtifactReceipt__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_FirmwareArtifactReceipt__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_FirmwareArtifactReceipt___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_FirmwareArtifactReceipt___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func cancelFirmwareArtifactDownloads(params: FirmwareArtifactCancelParams) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.cancelFirmwareArtifactDownloads(params: params)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func discardFirmwareArtifact(params: FirmwareArtifactRefParams) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.discardFirmwareArtifact(params: params)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func openFirmwareArtifact(params: FirmwareArtifactRefParams) -> bridge.Result_std__shared_ptr_Promise_FirmwareArtifactReaderInfo___ {
+    do {
+      let __result = try self.__implementation.openFirmwareArtifact(params: params)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_FirmwareArtifactReaderInfo__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_FirmwareArtifactReaderInfo__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_FirmwareArtifactReaderInfo__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_FirmwareArtifactReaderInfo___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_FirmwareArtifactReaderInfo___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func readFirmwareArtifact(params: FirmwareArtifactReaderReadParams) -> bridge.Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ {
+    do {
+      let __result = try self.__implementation.readFirmwareArtifact(params: params)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result.getArrayBuffer()) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func closeFirmwareArtifact(params: FirmwareArtifactReaderCloseParams) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.closeFirmwareArtifact(params: params)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func materializeFirmwareArchive(params: FirmwareArchiveMaterializeParams) -> bridge.Result_std__shared_ptr_Promise_FirmwareArchiveMaterializeResult___ {
+    do {
+      let __result = try self.__implementation.materializeFirmwareArchive(params: params)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_FirmwareArchiveMaterializeResult__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_FirmwareArchiveMaterializeResult__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_FirmwareArchiveMaterializeResult__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_FirmwareArchiveMaterializeResult___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_FirmwareArchiveMaterializeResult___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func createFirmwareArtifactLease(params: FirmwareArtifactLeaseCreateParams) -> bridge.Result_std__shared_ptr_Promise_FirmwareArtifactLease___ {
+    do {
+      let __result = try self.__implementation.createFirmwareArtifactLease(params: params)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_FirmwareArtifactLease__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_FirmwareArtifactLease__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_FirmwareArtifactLease__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_FirmwareArtifactLease___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_FirmwareArtifactLease___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func retainFirmwareArtifact(params: FirmwareArtifactLeaseRetainParams) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.retainFirmwareArtifact(params: params)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func releaseFirmwareArtifactLease(params: FirmwareArtifactLeaseReleaseParams) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.releaseFirmwareArtifactLease(params: params)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func reconcileFirmwareArtifactLeases(params: FirmwareArtifactLeaseReconcileParams) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.reconcileFirmwareArtifactLeases(params: params)
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_void__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve() })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func sweepFirmwareArtifactOrphans() -> bridge.Result_std__shared_ptr_Promise_FirmwareArtifactSweepResult___ {
+    do {
+      let __result = try self.__implementation.sweepFirmwareArtifactOrphans()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_FirmwareArtifactSweepResult__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_FirmwareArtifactSweepResult__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_FirmwareArtifactSweepResult__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_FirmwareArtifactSweepResult___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_FirmwareArtifactSweepResult___(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/shared/c++/DownloadChannel.hpp

@@ -32,6 +32,7 @@ namespace margelo::nitro::reactnativerangedownloader {
     BUNDLE      SWIFT_NAME(bundle) = 0,
     APK      SWIFT_NAME(apk) = 1,
     CHART      SWIFT_NAME(chart) = 2,
+    FIRMWARE      SWIFT_NAME(firmware) = 3,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::reactnativerangedownloader
@@ -47,6 +48,7 @@ namespace margelo::nitro {
         case hashString("bundle"): return margelo::nitro::reactnativerangedownloader::DownloadChannel::BUNDLE;
         case hashString("apk"): return margelo::nitro::reactnativerangedownloader::DownloadChannel::APK;
         case hashString("chart"): return margelo::nitro::reactnativerangedownloader::DownloadChannel::CHART;
+        case hashString("firmware"): return margelo::nitro::reactnativerangedownloader::DownloadChannel::FIRMWARE;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum DownloadChannel - invalid value!");
       }
@@ -56,6 +58,7 @@ namespace margelo::nitro {
         case margelo::nitro::reactnativerangedownloader::DownloadChannel::BUNDLE: return JSIConverter<std::string>::toJSI(runtime, "bundle");
         case margelo::nitro::reactnativerangedownloader::DownloadChannel::APK: return JSIConverter<std::string>::toJSI(runtime, "apk");
         case margelo::nitro::reactnativerangedownloader::DownloadChannel::CHART: return JSIConverter<std::string>::toJSI(runtime, "chart");
+        case margelo::nitro::reactnativerangedownloader::DownloadChannel::FIRMWARE: return JSIConverter<std::string>::toJSI(runtime, "firmware");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert DownloadChannel to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");
@@ -70,6 +73,7 @@ namespace margelo::nitro {
         case hashString("bundle"):
         case hashString("apk"):
         case hashString("chart"):
+        case hashString("firmware"):
           return true;
         default:
           return false;

package/nitrogen/generated/shared/c++/FirmwareArchiveExpectedEntry.hpp

@@ -0,0 +1,87 @@
+///
+/// FirmwareArchiveExpectedEntry.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+
+namespace margelo::nitro::reactnativerangedownloader {
+
+  /**
+   * A struct which can be represented as a JavaScript object (FirmwareArchiveExpectedEntry).
+   */
+  struct FirmwareArchiveExpectedEntry {
+  public:
+    std::string artifactId     SWIFT_PRIVATE;
+    std::string entryName     SWIFT_PRIVATE;
+    double expectedSize     SWIFT_PRIVATE;
+    std::string expectedSha256     SWIFT_PRIVATE;
+
+  public:
+    FirmwareArchiveExpectedEntry() = default;
+    explicit FirmwareArchiveExpectedEntry(std::string artifactId, std::string entryName, double expectedSize, std::string expectedSha256): artifactId(artifactId), entryName(entryName), expectedSize(expectedSize), expectedSha256(expectedSha256) {}
+  };
+
+} // namespace margelo::nitro::reactnativerangedownloader
+
+namespace margelo::nitro {
+
+  // C++ FirmwareArchiveExpectedEntry <> JS FirmwareArchiveExpectedEntry (object)
+  template <>
+  struct JSIConverter<margelo::nitro::reactnativerangedownloader::FirmwareArchiveExpectedEntry> final {
+    static inline margelo::nitro::reactnativerangedownloader::FirmwareArchiveExpectedEntry fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::reactnativerangedownloader::FirmwareArchiveExpectedEntry(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "artifactId")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "entryName")),
+        JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "expectedSize")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "expectedSha256"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::reactnativerangedownloader::FirmwareArchiveExpectedEntry& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "artifactId", JSIConverter<std::string>::toJSI(runtime, arg.artifactId));
+      obj.setProperty(runtime, "entryName", JSIConverter<std::string>::toJSI(runtime, arg.entryName));
+      obj.setProperty(runtime, "expectedSize", JSIConverter<double>::toJSI(runtime, arg.expectedSize));
+      obj.setProperty(runtime, "expectedSha256", JSIConverter<std::string>::toJSI(runtime, arg.expectedSha256));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "artifactId"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "entryName"))) return false;
+      if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "expectedSize"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "expectedSha256"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/FirmwareArchiveMaterializeParams.hpp

@@ -0,0 +1,86 @@
+///
+/// FirmwareArchiveMaterializeParams.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `FirmwareArchiveExpectedEntry` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArchiveExpectedEntry; }
+
+#include <string>
+#include "FirmwareArchiveExpectedEntry.hpp"
+#include <vector>
+
+namespace margelo::nitro::reactnativerangedownloader {
+
+  /**
+   * A struct which can be represented as a JavaScript object (FirmwareArchiveMaterializeParams).
+   */
+  struct FirmwareArchiveMaterializeParams {
+  public:
+    std::string leaseRef     SWIFT_PRIVATE;
+    std::string archiveArtifactRef     SWIFT_PRIVATE;
+    std::vector<FirmwareArchiveExpectedEntry> expectedEntries     SWIFT_PRIVATE;
+
+  public:
+    FirmwareArchiveMaterializeParams() = default;
+    explicit FirmwareArchiveMaterializeParams(std::string leaseRef, std::string archiveArtifactRef, std::vector<FirmwareArchiveExpectedEntry> expectedEntries): leaseRef(leaseRef), archiveArtifactRef(archiveArtifactRef), expectedEntries(expectedEntries) {}
+  };
+
+} // namespace margelo::nitro::reactnativerangedownloader
+
+namespace margelo::nitro {
+
+  // C++ FirmwareArchiveMaterializeParams <> JS FirmwareArchiveMaterializeParams (object)
+  template <>
+  struct JSIConverter<margelo::nitro::reactnativerangedownloader::FirmwareArchiveMaterializeParams> final {
+    static inline margelo::nitro::reactnativerangedownloader::FirmwareArchiveMaterializeParams fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::reactnativerangedownloader::FirmwareArchiveMaterializeParams(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "leaseRef")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "archiveArtifactRef")),
+        JSIConverter<std::vector<margelo::nitro::reactnativerangedownloader::FirmwareArchiveExpectedEntry>>::fromJSI(runtime, obj.getProperty(runtime, "expectedEntries"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::reactnativerangedownloader::FirmwareArchiveMaterializeParams& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "leaseRef", JSIConverter<std::string>::toJSI(runtime, arg.leaseRef));
+      obj.setProperty(runtime, "archiveArtifactRef", JSIConverter<std::string>::toJSI(runtime, arg.archiveArtifactRef));
+      obj.setProperty(runtime, "expectedEntries", JSIConverter<std::vector<margelo::nitro::reactnativerangedownloader::FirmwareArchiveExpectedEntry>>::toJSI(runtime, arg.expectedEntries));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "leaseRef"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "archiveArtifactRef"))) return false;
+      if (!JSIConverter<std::vector<margelo::nitro::reactnativerangedownloader::FirmwareArchiveExpectedEntry>>::canConvert(runtime, obj.getProperty(runtime, "expectedEntries"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/FirmwareArchiveMaterializeResult.hpp

@@ -0,0 +1,77 @@
+///
+/// FirmwareArchiveMaterializeResult.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `FirmwareArchiveMaterializedArtifact` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArchiveMaterializedArtifact; }
+
+#include "FirmwareArchiveMaterializedArtifact.hpp"
+#include <vector>
+
+namespace margelo::nitro::reactnativerangedownloader {
+
+  /**
+   * A struct which can be represented as a JavaScript object (FirmwareArchiveMaterializeResult).
+   */
+  struct FirmwareArchiveMaterializeResult {
+  public:
+    std::vector<FirmwareArchiveMaterializedArtifact> artifacts     SWIFT_PRIVATE;
+
+  public:
+    FirmwareArchiveMaterializeResult() = default;
+    explicit FirmwareArchiveMaterializeResult(std::vector<FirmwareArchiveMaterializedArtifact> artifacts): artifacts(artifacts) {}
+  };
+
+} // namespace margelo::nitro::reactnativerangedownloader
+
+namespace margelo::nitro {
+
+  // C++ FirmwareArchiveMaterializeResult <> JS FirmwareArchiveMaterializeResult (object)
+  template <>
+  struct JSIConverter<margelo::nitro::reactnativerangedownloader::FirmwareArchiveMaterializeResult> final {
+    static inline margelo::nitro::reactnativerangedownloader::FirmwareArchiveMaterializeResult fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::reactnativerangedownloader::FirmwareArchiveMaterializeResult(
+        JSIConverter<std::vector<margelo::nitro::reactnativerangedownloader::FirmwareArchiveMaterializedArtifact>>::fromJSI(runtime, obj.getProperty(runtime, "artifacts"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::reactnativerangedownloader::FirmwareArchiveMaterializeResult& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "artifacts", JSIConverter<std::vector<margelo::nitro::reactnativerangedownloader::FirmwareArchiveMaterializedArtifact>>::toJSI(runtime, arg.artifacts));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::vector<margelo::nitro::reactnativerangedownloader::FirmwareArchiveMaterializedArtifact>>::canConvert(runtime, obj.getProperty(runtime, "artifacts"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

package/nitrogen/generated/shared/c++/FirmwareArchiveMaterializedArtifact.hpp

@@ -0,0 +1,81 @@
+///
+/// FirmwareArchiveMaterializedArtifact.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `FirmwareArtifactReceipt` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactReceipt; }
+
+#include <string>
+#include "FirmwareArtifactReceipt.hpp"
+
+namespace margelo::nitro::reactnativerangedownloader {
+
+  /**
+   * A struct which can be represented as a JavaScript object (FirmwareArchiveMaterializedArtifact).
+   */
+  struct FirmwareArchiveMaterializedArtifact {
+  public:
+    std::string entryName     SWIFT_PRIVATE;
+    FirmwareArtifactReceipt receipt     SWIFT_PRIVATE;
+
+  public:
+    FirmwareArchiveMaterializedArtifact() = default;
+    explicit FirmwareArchiveMaterializedArtifact(std::string entryName, FirmwareArtifactReceipt receipt): entryName(entryName), receipt(receipt) {}
+  };
+
+} // namespace margelo::nitro::reactnativerangedownloader
+
+namespace margelo::nitro {
+
+  // C++ FirmwareArchiveMaterializedArtifact <> JS FirmwareArchiveMaterializedArtifact (object)
+  template <>
+  struct JSIConverter<margelo::nitro::reactnativerangedownloader::FirmwareArchiveMaterializedArtifact> final {
+    static inline margelo::nitro::reactnativerangedownloader::FirmwareArchiveMaterializedArtifact fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::reactnativerangedownloader::FirmwareArchiveMaterializedArtifact(
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "entryName")),
+        JSIConverter<margelo::nitro::reactnativerangedownloader::FirmwareArtifactReceipt>::fromJSI(runtime, obj.getProperty(runtime, "receipt"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::reactnativerangedownloader::FirmwareArchiveMaterializedArtifact& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "entryName", JSIConverter<std::string>::toJSI(runtime, arg.entryName));
+      obj.setProperty(runtime, "receipt", JSIConverter<margelo::nitro::reactnativerangedownloader::FirmwareArtifactReceipt>::toJSI(runtime, arg.receipt));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "entryName"))) return false;
+      if (!JSIConverter<margelo::nitro::reactnativerangedownloader::FirmwareArtifactReceipt>::canConvert(runtime, obj.getProperty(runtime, "receipt"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro