@onekeyfe/react-native-range-downloader 3.0.81 → 3.0.82

package/nitrogen/generated/ios/ReactNativeRangeDownloader-Swift-Cxx-Bridge.hpp

@@ -2,14 +2,32 @@
 /// ReactNativeRangeDownloader-Swift-Cxx-Bridge.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
 
 // Forward declarations of C++ defined types
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
 // Forward declaration of `DownloadChannel` to properly resolve imports.
 namespace margelo::nitro::reactnativerangedownloader { enum class DownloadChannel; }
+// Forward declaration of `FirmwareArchiveExpectedEntry` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArchiveExpectedEntry; }
+// Forward declaration of `FirmwareArchiveMaterializeResult` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArchiveMaterializeResult; }
+// Forward declaration of `FirmwareArchiveMaterializedArtifact` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArchiveMaterializedArtifact; }
+// Forward declaration of `FirmwareArtifactCapabilities` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactCapabilities; }
+// Forward declaration of `FirmwareArtifactLease` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactLease; }
+// Forward declaration of `FirmwareArtifactReaderInfo` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactReaderInfo; }
+// Forward declaration of `FirmwareArtifactReceipt` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactReceipt; }
+// Forward declaration of `FirmwareArtifactSweepResult` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactSweepResult; }
 // Forward declaration of `HybridReactNativeRangeDownloaderSpec` to properly resolve imports.
 namespace margelo::nitro::reactnativerangedownloader { class HybridReactNativeRangeDownloaderSpec; }
 // Forward declaration of `RangeDownloadEvent` to properly resolve imports.
@@ -27,11 +45,21 @@ namespace ReactNativeRangeDownloader { class HybridReactNativeRangeDownloaderSpe
 
 // Include C++ defined types
 #include "DownloadChannel.hpp"
+#include "FirmwareArchiveExpectedEntry.hpp"
+#include "FirmwareArchiveMaterializeResult.hpp"
+#include "FirmwareArchiveMaterializedArtifact.hpp"
+#include "FirmwareArtifactCapabilities.hpp"
+#include "FirmwareArtifactLease.hpp"
+#include "FirmwareArtifactReaderInfo.hpp"
+#include "FirmwareArtifactReceipt.hpp"
+#include "FirmwareArtifactSweepResult.hpp"
 #include "HybridReactNativeRangeDownloaderSpec.hpp"
 #include "RangeDownloadEvent.hpp"
 #include "RangeDownloadOutcome.hpp"
 #include "RangeDownloadResult.hpp"
 #include "RangeFallbackKind.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
 #include <NitroModules/Result.hpp>
@@ -40,6 +68,7 @@ namespace ReactNativeRangeDownloader { class HybridReactNativeRangeDownloaderSpe
 #include <memory>
 #include <optional>
 #include <string>
+#include <vector>
 
 /**
  * Contains specialized versions of C++ templated types so they can be accessed from Swift,
@@ -59,7 +88,7 @@ namespace margelo::nitro::reactnativerangedownloader::bridge::swift {
     return optional.has_value();
   }
   inline std::string get_std__optional_std__string_(const std::optional<std::string>& optional) noexcept {
-    return *optional;
+    return optional.value();
   }
   
   // pragma MARK: std::optional<RangeFallbackKind>
@@ -74,7 +103,7 @@ namespace margelo::nitro::reactnativerangedownloader::bridge::swift {
     return optional.has_value();
   }
   inline RangeFallbackKind get_std__optional_RangeFallbackKind_(const std::optional<RangeFallbackKind>& optional) noexcept {
-    return *optional;
+    return optional.value();
   }
   
   // pragma MARK: std::shared_ptr<Promise<RangeDownloadResult>>
@@ -145,7 +174,7 @@ namespace margelo::nitro::reactnativerangedownloader::bridge::swift {
     return optional.has_value();
   }
   inline double get_std__optional_double_(const std::optional<double>& optional) noexcept {
-    return *optional;
+    return optional.value();
   }
   
   // pragma MARK: std::shared_ptr<Promise<void>>
@@ -204,6 +233,258 @@ namespace margelo::nitro::reactnativerangedownloader::bridge::swift {
     return Func_void_RangeDownloadEvent_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::vector<std::string>
+  /**
+   * Specialized version of `std::vector<std::string>`.
+   */
+  using std__vector_std__string_ = std::vector<std::string>;
+  inline std::vector<std::string> create_std__vector_std__string_(size_t size) noexcept {
+    std::vector<std::string> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<FirmwareArtifactReceipt>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<FirmwareArtifactReceipt>>`.
+   */
+  using std__shared_ptr_Promise_FirmwareArtifactReceipt__ = std::shared_ptr<Promise<FirmwareArtifactReceipt>>;
+  inline std::shared_ptr<Promise<FirmwareArtifactReceipt>> create_std__shared_ptr_Promise_FirmwareArtifactReceipt__() noexcept {
+    return Promise<FirmwareArtifactReceipt>::create();
+  }
+  inline PromiseHolder<FirmwareArtifactReceipt> wrap_std__shared_ptr_Promise_FirmwareArtifactReceipt__(std::shared_ptr<Promise<FirmwareArtifactReceipt>> promise) noexcept {
+    return PromiseHolder<FirmwareArtifactReceipt>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const FirmwareArtifactReceipt& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const FirmwareArtifactReceipt&)>`.
+   */
+  using Func_void_FirmwareArtifactReceipt = std::function<void(const FirmwareArtifactReceipt& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const FirmwareArtifactReceipt& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_FirmwareArtifactReceipt_Wrapper final {
+  public:
+    explicit Func_void_FirmwareArtifactReceipt_Wrapper(std::function<void(const FirmwareArtifactReceipt& /* result */)>&& func): _function(std::make_unique<std::function<void(const FirmwareArtifactReceipt& /* result */)>>(std::move(func))) {}
+    inline void call(FirmwareArtifactReceipt result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const FirmwareArtifactReceipt& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_FirmwareArtifactReceipt create_Func_void_FirmwareArtifactReceipt(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_FirmwareArtifactReceipt_Wrapper wrap_Func_void_FirmwareArtifactReceipt(Func_void_FirmwareArtifactReceipt value) noexcept {
+    return Func_void_FirmwareArtifactReceipt_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<FirmwareArtifactReaderInfo>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<FirmwareArtifactReaderInfo>>`.
+   */
+  using std__shared_ptr_Promise_FirmwareArtifactReaderInfo__ = std::shared_ptr<Promise<FirmwareArtifactReaderInfo>>;
+  inline std::shared_ptr<Promise<FirmwareArtifactReaderInfo>> create_std__shared_ptr_Promise_FirmwareArtifactReaderInfo__() noexcept {
+    return Promise<FirmwareArtifactReaderInfo>::create();
+  }
+  inline PromiseHolder<FirmwareArtifactReaderInfo> wrap_std__shared_ptr_Promise_FirmwareArtifactReaderInfo__(std::shared_ptr<Promise<FirmwareArtifactReaderInfo>> promise) noexcept {
+    return PromiseHolder<FirmwareArtifactReaderInfo>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const FirmwareArtifactReaderInfo& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const FirmwareArtifactReaderInfo&)>`.
+   */
+  using Func_void_FirmwareArtifactReaderInfo = std::function<void(const FirmwareArtifactReaderInfo& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const FirmwareArtifactReaderInfo& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_FirmwareArtifactReaderInfo_Wrapper final {
+  public:
+    explicit Func_void_FirmwareArtifactReaderInfo_Wrapper(std::function<void(const FirmwareArtifactReaderInfo& /* result */)>&& func): _function(std::make_unique<std::function<void(const FirmwareArtifactReaderInfo& /* result */)>>(std::move(func))) {}
+    inline void call(FirmwareArtifactReaderInfo result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const FirmwareArtifactReaderInfo& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_FirmwareArtifactReaderInfo create_Func_void_FirmwareArtifactReaderInfo(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_FirmwareArtifactReaderInfo_Wrapper wrap_Func_void_FirmwareArtifactReaderInfo(Func_void_FirmwareArtifactReaderInfo value) noexcept {
+    return Func_void_FirmwareArtifactReaderInfo_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>`.
+   */
+  using std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___ = std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>;
+  inline std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> create_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___() noexcept {
+    return Promise<std::shared_ptr<ArrayBuffer>>::create();
+  }
+  inline PromiseHolder<std::shared_ptr<ArrayBuffer>> wrap_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___(std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> promise) noexcept {
+    return PromiseHolder<std::shared_ptr<ArrayBuffer>>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const std::shared_ptr<ArrayBuffer>&)>`.
+   */
+  using Func_void_std__shared_ptr_ArrayBuffer_ = std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::shared_ptr<ArrayBuffer>& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__shared_ptr_ArrayBuffer__Wrapper final {
+  public:
+    explicit Func_void_std__shared_ptr_ArrayBuffer__Wrapper(std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>&& func): _function(std::make_unique<std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>>(std::move(func))) {}
+    inline void call(ArrayBufferHolder result) const noexcept {
+      _function->operator()(result.getArrayBuffer());
+    }
+  private:
+    std::unique_ptr<std::function<void(const std::shared_ptr<ArrayBuffer>& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_std__shared_ptr_ArrayBuffer_ create_Func_void_std__shared_ptr_ArrayBuffer_(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_std__shared_ptr_ArrayBuffer__Wrapper wrap_Func_void_std__shared_ptr_ArrayBuffer_(Func_void_std__shared_ptr_ArrayBuffer_ value) noexcept {
+    return Func_void_std__shared_ptr_ArrayBuffer__Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<FirmwareArchiveMaterializedArtifact>
+  /**
+   * Specialized version of `std::vector<FirmwareArchiveMaterializedArtifact>`.
+   */
+  using std__vector_FirmwareArchiveMaterializedArtifact_ = std::vector<FirmwareArchiveMaterializedArtifact>;
+  inline std::vector<FirmwareArchiveMaterializedArtifact> create_std__vector_FirmwareArchiveMaterializedArtifact_(size_t size) noexcept {
+    std::vector<FirmwareArchiveMaterializedArtifact> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<FirmwareArchiveMaterializeResult>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<FirmwareArchiveMaterializeResult>>`.
+   */
+  using std__shared_ptr_Promise_FirmwareArchiveMaterializeResult__ = std::shared_ptr<Promise<FirmwareArchiveMaterializeResult>>;
+  inline std::shared_ptr<Promise<FirmwareArchiveMaterializeResult>> create_std__shared_ptr_Promise_FirmwareArchiveMaterializeResult__() noexcept {
+    return Promise<FirmwareArchiveMaterializeResult>::create();
+  }
+  inline PromiseHolder<FirmwareArchiveMaterializeResult> wrap_std__shared_ptr_Promise_FirmwareArchiveMaterializeResult__(std::shared_ptr<Promise<FirmwareArchiveMaterializeResult>> promise) noexcept {
+    return PromiseHolder<FirmwareArchiveMaterializeResult>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const FirmwareArchiveMaterializeResult& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const FirmwareArchiveMaterializeResult&)>`.
+   */
+  using Func_void_FirmwareArchiveMaterializeResult = std::function<void(const FirmwareArchiveMaterializeResult& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const FirmwareArchiveMaterializeResult& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_FirmwareArchiveMaterializeResult_Wrapper final {
+  public:
+    explicit Func_void_FirmwareArchiveMaterializeResult_Wrapper(std::function<void(const FirmwareArchiveMaterializeResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const FirmwareArchiveMaterializeResult& /* result */)>>(std::move(func))) {}
+    inline void call(FirmwareArchiveMaterializeResult result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const FirmwareArchiveMaterializeResult& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_FirmwareArchiveMaterializeResult create_Func_void_FirmwareArchiveMaterializeResult(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_FirmwareArchiveMaterializeResult_Wrapper wrap_Func_void_FirmwareArchiveMaterializeResult(Func_void_FirmwareArchiveMaterializeResult value) noexcept {
+    return Func_void_FirmwareArchiveMaterializeResult_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::vector<FirmwareArchiveExpectedEntry>
+  /**
+   * Specialized version of `std::vector<FirmwareArchiveExpectedEntry>`.
+   */
+  using std__vector_FirmwareArchiveExpectedEntry_ = std::vector<FirmwareArchiveExpectedEntry>;
+  inline std::vector<FirmwareArchiveExpectedEntry> create_std__vector_FirmwareArchiveExpectedEntry_(size_t size) noexcept {
+    std::vector<FirmwareArchiveExpectedEntry> vector;
+    vector.reserve(size);
+    return vector;
+  }
+  
+  // pragma MARK: std::optional<std::vector<FirmwareArchiveExpectedEntry>>
+  /**
+   * Specialized version of `std::optional<std::vector<FirmwareArchiveExpectedEntry>>`.
+   */
+  using std__optional_std__vector_FirmwareArchiveExpectedEntry__ = std::optional<std::vector<FirmwareArchiveExpectedEntry>>;
+  inline std::optional<std::vector<FirmwareArchiveExpectedEntry>> create_std__optional_std__vector_FirmwareArchiveExpectedEntry__(const std::vector<FirmwareArchiveExpectedEntry>& value) noexcept {
+    return std::optional<std::vector<FirmwareArchiveExpectedEntry>>(value);
+  }
+  inline bool has_value_std__optional_std__vector_FirmwareArchiveExpectedEntry__(const std::optional<std::vector<FirmwareArchiveExpectedEntry>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::vector<FirmwareArchiveExpectedEntry> get_std__optional_std__vector_FirmwareArchiveExpectedEntry__(const std::optional<std::vector<FirmwareArchiveExpectedEntry>>& optional) noexcept {
+    return optional.value();
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<FirmwareArtifactLease>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<FirmwareArtifactLease>>`.
+   */
+  using std__shared_ptr_Promise_FirmwareArtifactLease__ = std::shared_ptr<Promise<FirmwareArtifactLease>>;
+  inline std::shared_ptr<Promise<FirmwareArtifactLease>> create_std__shared_ptr_Promise_FirmwareArtifactLease__() noexcept {
+    return Promise<FirmwareArtifactLease>::create();
+  }
+  inline PromiseHolder<FirmwareArtifactLease> wrap_std__shared_ptr_Promise_FirmwareArtifactLease__(std::shared_ptr<Promise<FirmwareArtifactLease>> promise) noexcept {
+    return PromiseHolder<FirmwareArtifactLease>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const FirmwareArtifactLease& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const FirmwareArtifactLease&)>`.
+   */
+  using Func_void_FirmwareArtifactLease = std::function<void(const FirmwareArtifactLease& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const FirmwareArtifactLease& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_FirmwareArtifactLease_Wrapper final {
+  public:
+    explicit Func_void_FirmwareArtifactLease_Wrapper(std::function<void(const FirmwareArtifactLease& /* result */)>&& func): _function(std::make_unique<std::function<void(const FirmwareArtifactLease& /* result */)>>(std::move(func))) {}
+    inline void call(FirmwareArtifactLease result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const FirmwareArtifactLease& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_FirmwareArtifactLease create_Func_void_FirmwareArtifactLease(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_FirmwareArtifactLease_Wrapper wrap_Func_void_FirmwareArtifactLease(Func_void_FirmwareArtifactLease value) noexcept {
+    return Func_void_FirmwareArtifactLease_Wrapper(std::move(value));
+  }
+  
+  // pragma MARK: std::shared_ptr<Promise<FirmwareArtifactSweepResult>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<FirmwareArtifactSweepResult>>`.
+   */
+  using std__shared_ptr_Promise_FirmwareArtifactSweepResult__ = std::shared_ptr<Promise<FirmwareArtifactSweepResult>>;
+  inline std::shared_ptr<Promise<FirmwareArtifactSweepResult>> create_std__shared_ptr_Promise_FirmwareArtifactSweepResult__() noexcept {
+    return Promise<FirmwareArtifactSweepResult>::create();
+  }
+  inline PromiseHolder<FirmwareArtifactSweepResult> wrap_std__shared_ptr_Promise_FirmwareArtifactSweepResult__(std::shared_ptr<Promise<FirmwareArtifactSweepResult>> promise) noexcept {
+    return PromiseHolder<FirmwareArtifactSweepResult>(std::move(promise));
+  }
+  
+  // pragma MARK: std::function<void(const FirmwareArtifactSweepResult& /* result */)>
+  /**
+   * Specialized version of `std::function<void(const FirmwareArtifactSweepResult&)>`.
+   */
+  using Func_void_FirmwareArtifactSweepResult = std::function<void(const FirmwareArtifactSweepResult& /* result */)>;
+  /**
+   * Wrapper class for a `std::function<void(const FirmwareArtifactSweepResult& / * result * /)>`, this can be used from Swift.
+   */
+  class Func_void_FirmwareArtifactSweepResult_Wrapper final {
+  public:
+    explicit Func_void_FirmwareArtifactSweepResult_Wrapper(std::function<void(const FirmwareArtifactSweepResult& /* result */)>&& func): _function(std::make_unique<std::function<void(const FirmwareArtifactSweepResult& /* result */)>>(std::move(func))) {}
+    inline void call(FirmwareArtifactSweepResult result) const noexcept {
+      _function->operator()(result);
+    }
+  private:
+    std::unique_ptr<std::function<void(const FirmwareArtifactSweepResult& /* result */)>> _function;
+  } SWIFT_NONCOPYABLE;
+  Func_void_FirmwareArtifactSweepResult create_Func_void_FirmwareArtifactSweepResult(void* NON_NULL swiftClosureWrapper) noexcept;
+  inline Func_void_FirmwareArtifactSweepResult_Wrapper wrap_Func_void_FirmwareArtifactSweepResult(Func_void_FirmwareArtifactSweepResult value) noexcept {
+    return Func_void_FirmwareArtifactSweepResult_Wrapper(std::move(value));
+  }
+  
   // pragma MARK: std::shared_ptr<HybridReactNativeRangeDownloaderSpec>
   /**
    * Specialized version of `std::shared_ptr<HybridReactNativeRangeDownloaderSpec>`.
@@ -260,5 +541,68 @@ namespace margelo::nitro::reactnativerangedownloader::bridge::swift {
   inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) noexcept {
     return Result<std::string>::withError(error);
   }
+  
+  // pragma MARK: Result<FirmwareArtifactCapabilities>
+  using Result_FirmwareArtifactCapabilities_ = Result<FirmwareArtifactCapabilities>;
+  inline Result_FirmwareArtifactCapabilities_ create_Result_FirmwareArtifactCapabilities_(const FirmwareArtifactCapabilities& value) noexcept {
+    return Result<FirmwareArtifactCapabilities>::withValue(value);
+  }
+  inline Result_FirmwareArtifactCapabilities_ create_Result_FirmwareArtifactCapabilities_(const std::exception_ptr& error) noexcept {
+    return Result<FirmwareArtifactCapabilities>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<FirmwareArtifactReceipt>>>
+  using Result_std__shared_ptr_Promise_FirmwareArtifactReceipt___ = Result<std::shared_ptr<Promise<FirmwareArtifactReceipt>>>;
+  inline Result_std__shared_ptr_Promise_FirmwareArtifactReceipt___ create_Result_std__shared_ptr_Promise_FirmwareArtifactReceipt___(const std::shared_ptr<Promise<FirmwareArtifactReceipt>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<FirmwareArtifactReceipt>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_FirmwareArtifactReceipt___ create_Result_std__shared_ptr_Promise_FirmwareArtifactReceipt___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<FirmwareArtifactReceipt>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<FirmwareArtifactReaderInfo>>>
+  using Result_std__shared_ptr_Promise_FirmwareArtifactReaderInfo___ = Result<std::shared_ptr<Promise<FirmwareArtifactReaderInfo>>>;
+  inline Result_std__shared_ptr_Promise_FirmwareArtifactReaderInfo___ create_Result_std__shared_ptr_Promise_FirmwareArtifactReaderInfo___(const std::shared_ptr<Promise<FirmwareArtifactReaderInfo>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<FirmwareArtifactReaderInfo>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_FirmwareArtifactReaderInfo___ create_Result_std__shared_ptr_Promise_FirmwareArtifactReaderInfo___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<FirmwareArtifactReaderInfo>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>
+  using Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ = Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>;
+  inline Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(const std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<FirmwareArchiveMaterializeResult>>>
+  using Result_std__shared_ptr_Promise_FirmwareArchiveMaterializeResult___ = Result<std::shared_ptr<Promise<FirmwareArchiveMaterializeResult>>>;
+  inline Result_std__shared_ptr_Promise_FirmwareArchiveMaterializeResult___ create_Result_std__shared_ptr_Promise_FirmwareArchiveMaterializeResult___(const std::shared_ptr<Promise<FirmwareArchiveMaterializeResult>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<FirmwareArchiveMaterializeResult>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_FirmwareArchiveMaterializeResult___ create_Result_std__shared_ptr_Promise_FirmwareArchiveMaterializeResult___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<FirmwareArchiveMaterializeResult>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<FirmwareArtifactLease>>>
+  using Result_std__shared_ptr_Promise_FirmwareArtifactLease___ = Result<std::shared_ptr<Promise<FirmwareArtifactLease>>>;
+  inline Result_std__shared_ptr_Promise_FirmwareArtifactLease___ create_Result_std__shared_ptr_Promise_FirmwareArtifactLease___(const std::shared_ptr<Promise<FirmwareArtifactLease>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<FirmwareArtifactLease>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_FirmwareArtifactLease___ create_Result_std__shared_ptr_Promise_FirmwareArtifactLease___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<FirmwareArtifactLease>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<FirmwareArtifactSweepResult>>>
+  using Result_std__shared_ptr_Promise_FirmwareArtifactSweepResult___ = Result<std::shared_ptr<Promise<FirmwareArtifactSweepResult>>>;
+  inline Result_std__shared_ptr_Promise_FirmwareArtifactSweepResult___ create_Result_std__shared_ptr_Promise_FirmwareArtifactSweepResult___(const std::shared_ptr<Promise<FirmwareArtifactSweepResult>>& value) noexcept {
+    return Result<std::shared_ptr<Promise<FirmwareArtifactSweepResult>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_FirmwareArtifactSweepResult___ create_Result_std__shared_ptr_Promise_FirmwareArtifactSweepResult___(const std::exception_ptr& error) noexcept {
+    return Result<std::shared_ptr<Promise<FirmwareArtifactSweepResult>>>::withError(error);
+  }
 
 } // namespace margelo::nitro::reactnativerangedownloader::bridge::swift

package/nitrogen/generated/ios/ReactNativeRangeDownloader-Swift-Cxx-Umbrella.hpp

@@ -2,7 +2,7 @@
 /// ReactNativeRangeDownloader-Swift-Cxx-Umbrella.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
@@ -10,6 +10,40 @@
 // Forward declarations of C++ defined types
 // Forward declaration of `DownloadChannel` to properly resolve imports.
 namespace margelo::nitro::reactnativerangedownloader { enum class DownloadChannel; }
+// Forward declaration of `FirmwareArchiveExpectedEntry` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArchiveExpectedEntry; }
+// Forward declaration of `FirmwareArchiveMaterializeParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArchiveMaterializeParams; }
+// Forward declaration of `FirmwareArchiveMaterializeResult` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArchiveMaterializeResult; }
+// Forward declaration of `FirmwareArchiveMaterializedArtifact` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArchiveMaterializedArtifact; }
+// Forward declaration of `FirmwareArtifactCancelParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactCancelParams; }
+// Forward declaration of `FirmwareArtifactCapabilities` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactCapabilities; }
+// Forward declaration of `FirmwareArtifactDownloadParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactDownloadParams; }
+// Forward declaration of `FirmwareArtifactLeaseCreateParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactLeaseCreateParams; }
+// Forward declaration of `FirmwareArtifactLeaseReleaseParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactLeaseReleaseParams; }
+// Forward declaration of `FirmwareArtifactLeaseRetainParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactLeaseRetainParams; }
+// Forward declaration of `FirmwareArtifactLease` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactLease; }
+// Forward declaration of `FirmwareArtifactReaderCloseParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactReaderCloseParams; }
+// Forward declaration of `FirmwareArtifactReaderInfo` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactReaderInfo; }
+// Forward declaration of `FirmwareArtifactReaderReadParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactReaderReadParams; }
+// Forward declaration of `FirmwareArtifactReceipt` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactReceipt; }
+// Forward declaration of `FirmwareArtifactRefParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactRefParams; }
+// Forward declaration of `FirmwareArtifactSweepResult` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactSweepResult; }
 // Forward declaration of `HybridReactNativeRangeDownloaderSpec` to properly resolve imports.
 namespace margelo::nitro::reactnativerangedownloader { class HybridReactNativeRangeDownloaderSpec; }
 // Forward declaration of `RangeDownloadEvent` to properly resolve imports.
@@ -25,12 +59,30 @@ namespace margelo::nitro::reactnativerangedownloader { enum class RangeFallbackK
 
 // Include C++ defined types
 #include "DownloadChannel.hpp"
+#include "FirmwareArchiveExpectedEntry.hpp"
+#include "FirmwareArchiveMaterializeParams.hpp"
+#include "FirmwareArchiveMaterializeResult.hpp"
+#include "FirmwareArchiveMaterializedArtifact.hpp"
+#include "FirmwareArtifactCancelParams.hpp"
+#include "FirmwareArtifactCapabilities.hpp"
+#include "FirmwareArtifactDownloadParams.hpp"
+#include "FirmwareArtifactLease.hpp"
+#include "FirmwareArtifactLeaseCreateParams.hpp"
+#include "FirmwareArtifactLeaseReleaseParams.hpp"
+#include "FirmwareArtifactLeaseRetainParams.hpp"
+#include "FirmwareArtifactReaderCloseParams.hpp"
+#include "FirmwareArtifactReaderInfo.hpp"
+#include "FirmwareArtifactReaderReadParams.hpp"
+#include "FirmwareArtifactReceipt.hpp"
+#include "FirmwareArtifactRefParams.hpp"
+#include "FirmwareArtifactSweepResult.hpp"
 #include "HybridReactNativeRangeDownloaderSpec.hpp"
 #include "RangeDownloadEvent.hpp"
 #include "RangeDownloadOutcome.hpp"
 #include "RangeDownloadParams.hpp"
 #include "RangeDownloadResult.hpp"
 #include "RangeFallbackKind.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>
 #include <exception>
@@ -38,6 +90,7 @@ namespace margelo::nitro::reactnativerangedownloader { enum class RangeFallbackK
 #include <memory>
 #include <optional>
 #include <string>
+#include <vector>
 
 // C++ helpers for Swift
 #include "ReactNativeRangeDownloader-Swift-Cxx-Bridge.hpp"

package/nitrogen/generated/ios/ReactNativeRangeDownloaderAutolinking.mm

@@ -2,7 +2,7 @@
 /// ReactNativeRangeDownloaderAutolinking.mm
 /// 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 <Foundation/Foundation.h>

package/nitrogen/generated/ios/ReactNativeRangeDownloaderAutolinking.swift

@@ -2,19 +2,16 @@
 /// ReactNativeRangeDownloaderAutolinking.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 ReactNativeRangeDownloaderAutolinking {
   public typealias bridge = margelo.nitro.reactnativerangedownloader.bridge.swift
 
-  /**
-   * Creates an instance of a Swift class that implements `HybridReactNativeRangeDownloaderSpec`,
-   * and wraps it in a Swift class that can directly interop with C++ (`HybridReactNativeRangeDownloaderSpec_cxx`)
-   *
-   * This is generated by Nitrogen and will initialize the class specified
-   * in the `"autolinking"` property of `nitro.json` (in this case, `ReactNativeRangeDownloader`).
-   */
   public static func createReactNativeRangeDownloader() -> bridge.std__shared_ptr_HybridReactNativeRangeDownloaderSpec_ {
     let hybridObject = ReactNativeRangeDownloader()
     return { () -> bridge.std__shared_ptr_HybridReactNativeRangeDownloaderSpec_ in
@@ -22,4 +19,8 @@ public final class ReactNativeRangeDownloaderAutolinking {
       return __cxxWrapped.getCxxPart()
     }()
   }
+  
+  public static func isReactNativeRangeDownloaderRecyclable() -> Bool {
+    return ReactNativeRangeDownloader.self is any RecyclableView.Type
+  }
 }

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

@@ -2,7 +2,7 @@
 /// HybridReactNativeRangeDownloaderSpecSwift.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 "HybridReactNativeRangeDownloaderSpecSwift.hpp"