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

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

@@ -8,8 +8,26 @@
 #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,
@@ -204,6 +233,243 @@ 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::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 +526,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

@@ -10,6 +10,42 @@
 // 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 `FirmwareArtifactLeaseReconcileParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactLeaseReconcileParams; }
+// 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 +61,31 @@ 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 "FirmwareArtifactLeaseReconcileParams.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 +93,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/c++/HybridReactNativeRangeDownloaderSpecSwift.hpp

@@ -24,6 +24,44 @@ namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadParam
 namespace margelo::nitro::reactnativerangedownloader { enum class DownloadChannel; }
 // Forward declaration of `RangeDownloadEvent` to properly resolve imports.
 namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadEvent; }
+// Forward declaration of `FirmwareArtifactCapabilities` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactCapabilities; }
+// Forward declaration of `FirmwareArtifactReceipt` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactReceipt; }
+// Forward declaration of `FirmwareArtifactDownloadParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactDownloadParams; }
+// Forward declaration of `FirmwareArtifactCancelParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactCancelParams; }
+// Forward declaration of `FirmwareArtifactRefParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactRefParams; }
+// Forward declaration of `FirmwareArtifactReaderInfo` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactReaderInfo; }
+// Forward declaration of `ArrayBufferHolder` to properly resolve imports.
+namespace NitroModules { class ArrayBufferHolder; }
+// Forward declaration of `FirmwareArtifactReaderReadParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactReaderReadParams; }
+// Forward declaration of `FirmwareArtifactReaderCloseParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactReaderCloseParams; }
+// 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 `FirmwareArchiveMaterializeParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArchiveMaterializeParams; }
+// Forward declaration of `FirmwareArchiveExpectedEntry` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArchiveExpectedEntry; }
+// Forward declaration of `FirmwareArtifactLease` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactLease; }
+// Forward declaration of `FirmwareArtifactLeaseCreateParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactLeaseCreateParams; }
+// Forward declaration of `FirmwareArtifactLeaseRetainParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactLeaseRetainParams; }
+// Forward declaration of `FirmwareArtifactLeaseReleaseParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactLeaseReleaseParams; }
+// Forward declaration of `FirmwareArtifactLeaseReconcileParams` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactLeaseReconcileParams; }
+// Forward declaration of `FirmwareArtifactSweepResult` to properly resolve imports.
+namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactSweepResult; }
 
 #include "RangeDownloadResult.hpp"
 #include <NitroModules/Promise.hpp>
@@ -35,6 +73,27 @@ namespace margelo::nitro::reactnativerangedownloader { struct RangeDownloadEvent
 #include "DownloadChannel.hpp"
 #include "RangeDownloadEvent.hpp"
 #include <functional>
+#include "FirmwareArtifactCapabilities.hpp"
+#include <vector>
+#include "FirmwareArtifactReceipt.hpp"
+#include "FirmwareArtifactDownloadParams.hpp"
+#include "FirmwareArtifactCancelParams.hpp"
+#include "FirmwareArtifactRefParams.hpp"
+#include "FirmwareArtifactReaderInfo.hpp"
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include "FirmwareArtifactReaderReadParams.hpp"
+#include "FirmwareArtifactReaderCloseParams.hpp"
+#include "FirmwareArchiveMaterializeResult.hpp"
+#include "FirmwareArchiveMaterializedArtifact.hpp"
+#include "FirmwareArchiveMaterializeParams.hpp"
+#include "FirmwareArchiveExpectedEntry.hpp"
+#include "FirmwareArtifactLease.hpp"
+#include "FirmwareArtifactLeaseCreateParams.hpp"
+#include "FirmwareArtifactLeaseRetainParams.hpp"
+#include "FirmwareArtifactLeaseReleaseParams.hpp"
+#include "FirmwareArtifactLeaseReconcileParams.hpp"
+#include "FirmwareArtifactSweepResult.hpp"
 
 #include "ReactNativeRangeDownloader-Swift-Cxx-Umbrella.hpp"
 
@@ -126,6 +185,110 @@ namespace margelo::nitro::reactnativerangedownloader {
       auto __value = std::move(__result.value());
       return __value;
     }
+    inline FirmwareArtifactCapabilities getFirmwareArtifactCapabilities() override {
+      auto __result = _swiftPart.getFirmwareArtifactCapabilities();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<FirmwareArtifactReceipt>> downloadFirmwareArtifact(const FirmwareArtifactDownloadParams& params) override {
+      auto __result = _swiftPart.downloadFirmwareArtifact(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> cancelFirmwareArtifactDownloads(const FirmwareArtifactCancelParams& params) override {
+      auto __result = _swiftPart.cancelFirmwareArtifactDownloads(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> discardFirmwareArtifact(const FirmwareArtifactRefParams& params) override {
+      auto __result = _swiftPart.discardFirmwareArtifact(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<FirmwareArtifactReaderInfo>> openFirmwareArtifact(const FirmwareArtifactRefParams& params) override {
+      auto __result = _swiftPart.openFirmwareArtifact(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> readFirmwareArtifact(const FirmwareArtifactReaderReadParams& params) override {
+      auto __result = _swiftPart.readFirmwareArtifact(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> closeFirmwareArtifact(const FirmwareArtifactReaderCloseParams& params) override {
+      auto __result = _swiftPart.closeFirmwareArtifact(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<FirmwareArchiveMaterializeResult>> materializeFirmwareArchive(const FirmwareArchiveMaterializeParams& params) override {
+      auto __result = _swiftPart.materializeFirmwareArchive(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<FirmwareArtifactLease>> createFirmwareArtifactLease(const FirmwareArtifactLeaseCreateParams& params) override {
+      auto __result = _swiftPart.createFirmwareArtifactLease(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> retainFirmwareArtifact(const FirmwareArtifactLeaseRetainParams& params) override {
+      auto __result = _swiftPart.retainFirmwareArtifact(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> releaseFirmwareArtifactLease(const FirmwareArtifactLeaseReleaseParams& params) override {
+      auto __result = _swiftPart.releaseFirmwareArtifactLease(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> reconcileFirmwareArtifactLeases(const FirmwareArtifactLeaseReconcileParams& params) override {
+      auto __result = _swiftPart.reconcileFirmwareArtifactLeases(std::forward<decltype(params)>(params));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<FirmwareArtifactSweepResult>> sweepFirmwareArtifactOrphans() override {
+      auto __result = _swiftPart.sweepFirmwareArtifactOrphans();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     ReactNativeRangeDownloader::HybridReactNativeRangeDownloaderSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/DownloadChannel.swift

@@ -23,6 +23,8 @@ public extension DownloadChannel {
         self = .apk
       case "chart":
         self = .chart
+      case "firmware":
+        self = .firmware
       default:
         return nil
     }
@@ -39,6 +41,8 @@ public extension DownloadChannel {
         return "apk"
       case .chart:
         return "chart"
+      case .firmware:
+        return "firmware"
     }
   }
 }