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

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

@@ -8,26 +8,8 @@
 #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.
@@ -45,21 +27,11 @@ 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>
@@ -68,7 +40,6 @@ 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,
@@ -233,243 +204,6 @@ 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>`.
@@ -526,68 +260,5 @@ 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,40 +10,6 @@
 // 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.
@@ -59,30 +25,12 @@ 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>
@@ -90,7 +38,6 @@ 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,42 +24,6 @@ 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 `FirmwareArtifactSweepResult` to properly resolve imports.
-namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactSweepResult; }
 
 #include "RangeDownloadResult.hpp"
 #include <NitroModules/Promise.hpp>
@@ -71,26 +35,6 @@ namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactSw
 #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 "FirmwareArtifactSweepResult.hpp"
 
 #include "ReactNativeRangeDownloader-Swift-Cxx-Umbrella.hpp"
 
@@ -182,102 +126,6 @@ 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<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,8 +23,6 @@ public extension DownloadChannel {
         self = .apk
       case "chart":
         self = .chart
-      case "firmware":
-        self = .firmware
       default:
         return nil
     }
@@ -41,8 +39,6 @@ public extension DownloadChannel {
         return "apk"
       case .chart:
         return "chart"
-      case .firmware:
-        return "firmware"
     }
   }
 }