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

package/nitrogen/generated/ios/swift/HybridReactNativeRangeDownloaderSpec.swift

@@ -20,18 +20,6 @@ public protocol HybridReactNativeRangeDownloaderSpec_protocol: HybridObject {
   func addDownloadListener(callback: @escaping (_ event: RangeDownloadEvent) -> Void) throws -> Double
   func removeDownloadListener(id: Double) throws -> Void
   func getDownloadsDir() throws -> String
-  func getFirmwareArtifactCapabilities() throws -> FirmwareArtifactCapabilities
-  func downloadFirmwareArtifact(params: FirmwareArtifactDownloadParams) throws -> Promise<FirmwareArtifactReceipt>
-  func cancelFirmwareArtifactDownloads(params: FirmwareArtifactCancelParams) throws -> Promise<Void>
-  func discardFirmwareArtifact(params: FirmwareArtifactRefParams) throws -> Promise<Void>
-  func openFirmwareArtifact(params: FirmwareArtifactRefParams) throws -> Promise<FirmwareArtifactReaderInfo>
-  func readFirmwareArtifact(params: FirmwareArtifactReaderReadParams) throws -> Promise<ArrayBuffer>
-  func closeFirmwareArtifact(params: FirmwareArtifactReaderCloseParams) throws -> Promise<Void>
-  func materializeFirmwareArchive(params: FirmwareArchiveMaterializeParams) throws -> Promise<FirmwareArchiveMaterializeResult>
-  func createFirmwareArtifactLease(params: FirmwareArtifactLeaseCreateParams) throws -> Promise<FirmwareArtifactLease>
-  func retainFirmwareArtifact(params: FirmwareArtifactLeaseRetainParams) throws -> Promise<Void>
-  func releaseFirmwareArtifactLease(params: FirmwareArtifactLeaseReleaseParams) throws -> Promise<Void>
-  func sweepFirmwareArtifactOrphans() throws -> Promise<FirmwareArtifactSweepResult>
 }
 
 public extension HybridReactNativeRangeDownloaderSpec_protocol {

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

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

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

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

package/nitrogen/generated/shared/c++/HybridReactNativeRangeDownloaderSpec.cpp

@@ -20,18 +20,6 @@ namespace margelo::nitro::reactnativerangedownloader {
       prototype.registerHybridMethod("addDownloadListener", &HybridReactNativeRangeDownloaderSpec::addDownloadListener);
       prototype.registerHybridMethod("removeDownloadListener", &HybridReactNativeRangeDownloaderSpec::removeDownloadListener);
       prototype.registerHybridMethod("getDownloadsDir", &HybridReactNativeRangeDownloaderSpec::getDownloadsDir);
-      prototype.registerHybridMethod("getFirmwareArtifactCapabilities", &HybridReactNativeRangeDownloaderSpec::getFirmwareArtifactCapabilities);
-      prototype.registerHybridMethod("downloadFirmwareArtifact", &HybridReactNativeRangeDownloaderSpec::downloadFirmwareArtifact);
-      prototype.registerHybridMethod("cancelFirmwareArtifactDownloads", &HybridReactNativeRangeDownloaderSpec::cancelFirmwareArtifactDownloads);
-      prototype.registerHybridMethod("discardFirmwareArtifact", &HybridReactNativeRangeDownloaderSpec::discardFirmwareArtifact);
-      prototype.registerHybridMethod("openFirmwareArtifact", &HybridReactNativeRangeDownloaderSpec::openFirmwareArtifact);
-      prototype.registerHybridMethod("readFirmwareArtifact", &HybridReactNativeRangeDownloaderSpec::readFirmwareArtifact);
-      prototype.registerHybridMethod("closeFirmwareArtifact", &HybridReactNativeRangeDownloaderSpec::closeFirmwareArtifact);
-      prototype.registerHybridMethod("materializeFirmwareArchive", &HybridReactNativeRangeDownloaderSpec::materializeFirmwareArchive);
-      prototype.registerHybridMethod("createFirmwareArtifactLease", &HybridReactNativeRangeDownloaderSpec::createFirmwareArtifactLease);
-      prototype.registerHybridMethod("retainFirmwareArtifact", &HybridReactNativeRangeDownloaderSpec::retainFirmwareArtifact);
-      prototype.registerHybridMethod("releaseFirmwareArtifactLease", &HybridReactNativeRangeDownloaderSpec::releaseFirmwareArtifactLease);
-      prototype.registerHybridMethod("sweepFirmwareArtifactOrphans", &HybridReactNativeRangeDownloaderSpec::sweepFirmwareArtifactOrphans);
     });
   }
 

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

@@ -21,36 +21,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 `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 `FirmwareArchiveMaterializeParams` to properly resolve imports.
-namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArchiveMaterializeParams; }
-// 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>
@@ -59,22 +29,6 @@ namespace margelo::nitro::reactnativerangedownloader { struct FirmwareArtifactSw
 #include <string>
 #include "RangeDownloadEvent.hpp"
 #include <functional>
-#include "FirmwareArtifactCapabilities.hpp"
-#include "FirmwareArtifactReceipt.hpp"
-#include "FirmwareArtifactDownloadParams.hpp"
-#include "FirmwareArtifactCancelParams.hpp"
-#include "FirmwareArtifactRefParams.hpp"
-#include "FirmwareArtifactReaderInfo.hpp"
-#include <NitroModules/ArrayBuffer.hpp>
-#include "FirmwareArtifactReaderReadParams.hpp"
-#include "FirmwareArtifactReaderCloseParams.hpp"
-#include "FirmwareArchiveMaterializeResult.hpp"
-#include "FirmwareArchiveMaterializeParams.hpp"
-#include "FirmwareArtifactLease.hpp"
-#include "FirmwareArtifactLeaseCreateParams.hpp"
-#include "FirmwareArtifactLeaseRetainParams.hpp"
-#include "FirmwareArtifactLeaseReleaseParams.hpp"
-#include "FirmwareArtifactSweepResult.hpp"
 
 namespace margelo::nitro::reactnativerangedownloader {
 
@@ -113,18 +67,6 @@ namespace margelo::nitro::reactnativerangedownloader {
       virtual double addDownloadListener(const std::function<void(const RangeDownloadEvent& /* event */)>& callback) = 0;
       virtual void removeDownloadListener(double id) = 0;
       virtual std::string getDownloadsDir() = 0;
-      virtual FirmwareArtifactCapabilities getFirmwareArtifactCapabilities() = 0;
-      virtual std::shared_ptr<Promise<FirmwareArtifactReceipt>> downloadFirmwareArtifact(const FirmwareArtifactDownloadParams& params) = 0;
-      virtual std::shared_ptr<Promise<void>> cancelFirmwareArtifactDownloads(const FirmwareArtifactCancelParams& params) = 0;
-      virtual std::shared_ptr<Promise<void>> discardFirmwareArtifact(const FirmwareArtifactRefParams& params) = 0;
-      virtual std::shared_ptr<Promise<FirmwareArtifactReaderInfo>> openFirmwareArtifact(const FirmwareArtifactRefParams& params) = 0;
-      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> readFirmwareArtifact(const FirmwareArtifactReaderReadParams& params) = 0;
-      virtual std::shared_ptr<Promise<void>> closeFirmwareArtifact(const FirmwareArtifactReaderCloseParams& params) = 0;
-      virtual std::shared_ptr<Promise<FirmwareArchiveMaterializeResult>> materializeFirmwareArchive(const FirmwareArchiveMaterializeParams& params) = 0;
-      virtual std::shared_ptr<Promise<FirmwareArtifactLease>> createFirmwareArtifactLease(const FirmwareArtifactLeaseCreateParams& params) = 0;
-      virtual std::shared_ptr<Promise<void>> retainFirmwareArtifact(const FirmwareArtifactLeaseRetainParams& params) = 0;
-      virtual std::shared_ptr<Promise<void>> releaseFirmwareArtifactLease(const FirmwareArtifactLeaseReleaseParams& params) = 0;
-      virtual std::shared_ptr<Promise<FirmwareArtifactSweepResult>> sweepFirmwareArtifactOrphans() = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-range-downloader",
-  "version": "3.0.81-alpha.7",
+  "version": "3.0.81",
   "description": "react-native-range-downloader",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -88,7 +88,6 @@
     "typescript": "^5.9.2"
   },
   "peerDependencies": {
-    "@onekeyfe/react-native-sni-connect": "3.0.81-alpha.7",
     "react": "*",
     "react-native": "*",
     "react-native-nitro-modules": "0.33.2"
@@ -166,6 +165,5 @@
       "release-it"
     ],
     "version": "0.56.0"
-  },
-  "stableVersion": "3.0.80"
+  }
 }

package/src/ReactNativeRangeDownloader.nitro.ts

@@ -4,7 +4,7 @@ import type { HybridObject } from 'react-native-nitro-modules';
 // The channel decides the iOS background URLSession identifier suffix and the
 // event-routing key, so different consumers never cross-talk. Closed set per
 // design decision 10.1 (constant enum, not a bare string).
-export type DownloadChannel = 'bundle' | 'apk' | 'chart' | 'firmware';
+export type DownloadChannel = 'bundle' | 'apk' | 'chart';
 
 export interface RangeDownloadParams {
   channel: DownloadChannel;
@@ -68,101 +68,6 @@ export interface RangeDownloadEvent {
   message: string;
 }
 
-export interface FirmwareArtifactDownloadParams {
-  taskId: string;
-  transactionId: string;
-  leaseRef: string;
-  artifactId: string;
-  url: string;
-  routeType: string;
-  resolvedIp?: string;
-  expectedSize: number;
-  expectedSha256: string;
-  maxBytes: number;
-  overallDeadlineSeconds?: number; // defaults to 180; must be > 0 and <= 24 hours
-}
-
-export interface FirmwareArtifactReceipt {
-  artifactRef: string;
-  size: number;
-  sha256: string;
-}
-
-export interface FirmwareArtifactCapabilities {
-  firmwareArtifactProtocolVersion: number;
-  supportedRouteTypes: string[];
-  supportsArchiveMaterialization: boolean;
-  maxReadBytes: number;
-}
-
-export interface FirmwareArtifactRefParams {
-  artifactRef: string;
-}
-
-export interface FirmwareArtifactCancelParams {
-  transactionId: string;
-}
-
-export interface FirmwareArtifactReaderInfo {
-  readerId: string;
-  size: number;
-}
-
-export interface FirmwareArtifactReaderReadParams {
-  readerId: string;
-  offset: number;
-  length: number;
-}
-
-export interface FirmwareArtifactReaderCloseParams {
-  readerId: string;
-}
-
-export interface FirmwareArchiveMaterializeParams {
-  leaseRef: string;
-  archiveArtifactRef: string;
-  expectedEntries: FirmwareArchiveExpectedEntry[];
-}
-
-export interface FirmwareArchiveExpectedEntry {
-  artifactId: string;
-  entryName: string;
-  expectedSize: number;
-  expectedSha256: string;
-}
-
-export interface FirmwareArchiveMaterializedArtifact {
-  entryName: string;
-  receipt: FirmwareArtifactReceipt;
-}
-
-export interface FirmwareArchiveMaterializeResult {
-  artifacts: FirmwareArchiveMaterializedArtifact[];
-}
-
-export interface FirmwareArtifactLeaseCreateParams {
-  transactionId: string;
-}
-
-export interface FirmwareArtifactLease {
-  leaseRef: string;
-}
-
-export interface FirmwareArtifactLeaseRetainParams {
-  leaseRef: string;
-  artifactRef: string;
-}
-
-export interface FirmwareArtifactLeaseReleaseParams {
-  leaseRef: string;
-  disposition: string;
-}
-
-export interface FirmwareArtifactSweepResult {
-  deletedFiles: number;
-  deletedBytes: number;
-}
-
 export interface ReactNativeRangeDownloader
   extends HybridObject<{ ios: 'swift'; android: 'kotlin' }> {
   // Main entry: concurrent ranged download (iOS background session / Android thread pool).
@@ -197,35 +102,4 @@ export interface ReactNativeRangeDownloader
   // not own directory layout for real consumers, but exposes this so demos/simple
   // callers have a valid absolute destination without hardcoding sandbox paths.
   getDownloadsDir(): string;
-
-  getFirmwareArtifactCapabilities(): FirmwareArtifactCapabilities;
-  downloadFirmwareArtifact(
-    params: FirmwareArtifactDownloadParams
-  ): Promise<FirmwareArtifactReceipt>;
-  cancelFirmwareArtifactDownloads(
-    params: FirmwareArtifactCancelParams
-  ): Promise<void>;
-  discardFirmwareArtifact(params: FirmwareArtifactRefParams): Promise<void>;
-  openFirmwareArtifact(
-    params: FirmwareArtifactRefParams
-  ): Promise<FirmwareArtifactReaderInfo>;
-  readFirmwareArtifact(
-    params: FirmwareArtifactReaderReadParams
-  ): Promise<ArrayBuffer>;
-  closeFirmwareArtifact(
-    params: FirmwareArtifactReaderCloseParams
-  ): Promise<void>;
-  materializeFirmwareArchive(
-    params: FirmwareArchiveMaterializeParams
-  ): Promise<FirmwareArchiveMaterializeResult>;
-  createFirmwareArtifactLease(
-    params: FirmwareArtifactLeaseCreateParams
-  ): Promise<FirmwareArtifactLease>;
-  retainFirmwareArtifact(
-    params: FirmwareArtifactLeaseRetainParams
-  ): Promise<void>;
-  releaseFirmwareArtifactLease(
-    params: FirmwareArtifactLeaseReleaseParams
-  ): Promise<void>;
-  sweepFirmwareArtifactOrphans(): Promise<FirmwareArtifactSweepResult>;
 }

package/src/index.tsx

@@ -6,8 +6,7 @@ const ReactNativeRangeDownloaderHybridObject =
     'ReactNativeRangeDownloader'
   );
 
-export const ReactNativeRangeDownloader =
-  ReactNativeRangeDownloaderHybridObject;
+export const ReactNativeRangeDownloader = ReactNativeRangeDownloaderHybridObject;
 
 // Closed set of download channels (design decision 10.1). The native side builds the
 // background session identifier as `so.onekey.rangedownloader.bg.<channel>`. New channels
@@ -16,7 +15,6 @@ export const RangeDownloadChannel = {
   Bundle: 'bundle',
   Apk: 'apk',
   Chart: 'chart',
-  Firmware: 'firmware',
 } as const;
 
 export type * from './ReactNativeRangeDownloader.nitro';