@onekeyfe/react-native-bundle-crypto 3.0.39

package/nitrogen/generated/ios/swift/HybridReactNativeBundleCryptoSpec_cxx.swift

@@ -0,0 +1,314 @@
+///
+/// HybridReactNativeBundleCryptoSpec_cxx.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * A class implementation that bridges HybridReactNativeBundleCryptoSpec over to C++.
+ * In C++, we cannot use Swift protocols - so we need to wrap it in a class to make it strongly defined.
+ *
+ * Also, some Swift types need to be bridged with special handling:
+ * - Enums need to be wrapped in Structs, otherwise they cannot be accessed bi-directionally (Swift bug: https://github.com/swiftlang/swift/issues/75330)
+ * - Other HybridObjects need to be wrapped/unwrapped from the Swift TCxx wrapper
+ * - Throwing methods need to be wrapped with a Result<T, Error> type, as exceptions cannot be propagated to C++
+ */
+open class HybridReactNativeBundleCryptoSpec_cxx {
+  /**
+   * The Swift <> C++ bridge's namespace (`margelo::nitro::reactnativebundlecrypto::bridge::swift`)
+   * from `ReactNativeBundleCrypto-Swift-Cxx-Bridge.hpp`.
+   * This contains specialized C++ templates, and C++ helper functions that can be accessed from Swift.
+   */
+  public typealias bridge = margelo.nitro.reactnativebundlecrypto.bridge.swift
+
+  /**
+   * Holds an instance of the `HybridReactNativeBundleCryptoSpec` Swift protocol.
+   */
+  private var __implementation: any HybridReactNativeBundleCryptoSpec
+
+  /**
+   * Holds a weak pointer to the C++ class that wraps the Swift class.
+   */
+  private var __cxxPart: bridge.std__weak_ptr_HybridReactNativeBundleCryptoSpec_
+
+  /**
+   * Create a new `HybridReactNativeBundleCryptoSpec_cxx` that wraps the given `HybridReactNativeBundleCryptoSpec`.
+   * All properties and methods bridge to C++ types.
+   */
+  public init(_ implementation: any HybridReactNativeBundleCryptoSpec) {
+    self.__implementation = implementation
+    self.__cxxPart = .init()
+    /* no base class */
+  }
+
+  /**
+   * Get the actual `HybridReactNativeBundleCryptoSpec` instance this class wraps.
+   */
+  @inline(__always)
+  public func getHybridReactNativeBundleCryptoSpec() -> any HybridReactNativeBundleCryptoSpec {
+    return __implementation
+  }
+
+  /**
+   * Casts this instance to a retained unsafe raw pointer.
+   * This acquires one additional strong reference on the object!
+   */
+  public func toUnsafe() -> UnsafeMutableRawPointer {
+    return Unmanaged.passRetained(self).toOpaque()
+  }
+
+  /**
+   * Casts an unsafe pointer to a `HybridReactNativeBundleCryptoSpec_cxx`.
+   * The pointer has to be a retained opaque `Unmanaged<HybridReactNativeBundleCryptoSpec_cxx>`.
+   * This removes one strong reference from the object!
+   */
+  public class func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> HybridReactNativeBundleCryptoSpec_cxx {
+    return Unmanaged<HybridReactNativeBundleCryptoSpec_cxx>.fromOpaque(pointer).takeRetainedValue()
+  }
+
+  /**
+   * Gets (or creates) the C++ part of this Hybrid Object.
+   * The C++ part is a `std::shared_ptr<HybridReactNativeBundleCryptoSpec>`.
+   */
+  public func getCxxPart() -> bridge.std__shared_ptr_HybridReactNativeBundleCryptoSpec_ {
+    let cachedCxxPart = self.__cxxPart.lock()
+    if Bool(fromCxx: cachedCxxPart) {
+      return cachedCxxPart
+    } else {
+      let newCxxPart = bridge.create_std__shared_ptr_HybridReactNativeBundleCryptoSpec_(self.toUnsafe())
+      __cxxPart = bridge.weakify_std__shared_ptr_HybridReactNativeBundleCryptoSpec_(newCxxPart)
+      return newCxxPart
+    }
+  }
+
+  
+
+  /**
+   * Get the memory size of the Swift class (plus size of any other allocations)
+   * so the JS VM can properly track it and garbage-collect the JS object if needed.
+   */
+  @inline(__always)
+  public var memorySize: Int {
+    return MemoryHelper.getSizeOf(self.__implementation) + self.__implementation.memorySize
+  }
+
+  /**
+   * Call dispose() on the Swift class.
+   * This _may_ be called manually from JS.
+   */
+  @inline(__always)
+  public func dispose() {
+    self.__implementation.dispose()
+  }
+
+  /**
+   * Call toString() on the Swift class.
+   */
+  @inline(__always)
+  public func toString() -> String {
+    return self.__implementation.toString()
+  }
+
+  // Properties
+  
+
+  // Methods
+  @inline(__always)
+  public final func verifyGpgCleartext(signedMessage: std.string) -> bridge.Result_std__shared_ptr_Promise_VerifyGpgCleartextResult___ {
+    do {
+      let __result = try self.__implementation.verifyGpgCleartext(signedMessage: String(signedMessage))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_VerifyGpgCleartextResult__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_VerifyGpgCleartextResult__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_VerifyGpgCleartextResult__(__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_VerifyGpgCleartextResult___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_VerifyGpgCleartextResult___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func verifyDetachedAsc(ascContent: std.string) -> bridge.Result_std__shared_ptr_Promise_VerifyDetachedAscResult___ {
+    do {
+      let __result = try self.__implementation.verifyDetachedAsc(ascContent: String(ascContent))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_VerifyDetachedAscResult__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_VerifyDetachedAscResult__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_VerifyDetachedAscResult__(__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_VerifyDetachedAscResult___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_VerifyDetachedAscResult___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func sha256OfFile(filePath: std.string) -> bridge.Result_std__shared_ptr_Promise_Sha256Result___ {
+    do {
+      let __result = try self.__implementation.sha256OfFile(filePath: String(filePath))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_Sha256Result__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_Sha256Result__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_Sha256Result__(__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_Sha256Result___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_Sha256Result___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func secureEqualHex(a: std.string, b: std.string) -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.secureEqualHex(a: String(a), b: String(b))
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func verifyDirAgainstHashes(dirPath: std.string, entries: bridge.std__vector_DirHashEntry_) -> bridge.Result_std__shared_ptr_Promise_bool___ {
+    do {
+      let __result = try self.__implementation.verifyDirAgainstHashes(dirPath: String(dirPath), entries: entries.map({ __item in __item }))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_bool__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__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_bool___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func hashDir(dirPath: std.string) -> bridge.Result_std__shared_ptr_Promise_std__vector_DirHashEntry____ {
+    do {
+      let __result = try self.__implementation.hashDir(dirPath: String(dirPath))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__vector_DirHashEntry___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__vector_DirHashEntry___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__vector_DirHashEntry___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__vector_DirHashEntry_ in
+              var __vector = bridge.create_std__vector_DirHashEntry_(__result.count)
+              for __item in __result {
+                __vector.push_back(__item)
+              }
+              return __vector
+            }()) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_DirHashEntry____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_DirHashEntry____(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func validateExtractedPathSafety(destination: std.string) -> bridge.Result_std__shared_ptr_Promise_bool___ {
+    do {
+      let __result = try self.__implementation.validateExtractedPathSafety(destination: String(destination))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_bool__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__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_bool___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func atomicWriteFile(filePath: std.string, contentUtf8: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.atomicWriteFile(filePath: String(filePath), contentUtf8: String(contentUtf8))
+      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 safeRename(fromPath: std.string, toPath: std.string) -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.safeRename(fromPath: String(fromPath), toPath: String(toPath))
+      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 listVersionDirs(parentDir: std.string) -> bridge.Result_std__shared_ptr_Promise_std__vector_std__string____ {
+    do {
+      let __result = try self.__implementation.listVersionDirs(parentDir: String(parentDir))
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__vector_std__string___ in
+        let __promise = bridge.create_std__shared_ptr_Promise_std__vector_std__string___()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_std__vector_std__string___(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve({ () -> bridge.std__vector_std__string_ in
+              var __vector = bridge.create_std__vector_std__string_(__result.count)
+              for __item in __result {
+                __vector.push_back(std.string(__item))
+              }
+              return __vector
+            }()) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_std__string____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__vector_std__string____(__exceptionPtr)
+    }
+  }
+}

package/nitrogen/generated/ios/swift/Sha256Result.swift

@@ -0,0 +1,85 @@
+///
+/// Sha256Result.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Represents an instance of `Sha256Result`, backed by a C++ struct.
+ */
+public typealias Sha256Result = margelo.nitro.reactnativebundlecrypto.Sha256Result
+
+public extension Sha256Result {
+  private typealias bridge = margelo.nitro.reactnativebundlecrypto.bridge.swift
+
+  /**
+   * Create a new instance of `Sha256Result`.
+   */
+  init(sha256: String?, failureReason: String?) {
+    self.init({ () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = sha256 {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = failureReason {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  var sha256: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if bridge.has_value_std__optional_std__string_(self.__sha256) {
+          let __unwrapped = bridge.get_std__optional_std__string_(self.__sha256)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__sha256 = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var failureReason: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if bridge.has_value_std__optional_std__string_(self.__failureReason) {
+          let __unwrapped = bridge.get_std__optional_std__string_(self.__failureReason)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__failureReason = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+}

package/nitrogen/generated/ios/swift/VerifyDetachedAscResult.swift

@@ -0,0 +1,96 @@
+///
+/// VerifyDetachedAscResult.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Represents an instance of `VerifyDetachedAscResult`, backed by a C++ struct.
+ */
+public typealias VerifyDetachedAscResult = margelo.nitro.reactnativebundlecrypto.VerifyDetachedAscResult
+
+public extension VerifyDetachedAscResult {
+  private typealias bridge = margelo.nitro.reactnativebundlecrypto.bridge.swift
+
+  /**
+   * Create a new instance of `VerifyDetachedAscResult`.
+   */
+  init(valid: Bool, sha256: String?, reason: String?) {
+    self.init(valid, { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = sha256 {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = reason {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  var valid: Bool {
+    @inline(__always)
+    get {
+      return self.__valid
+    }
+    @inline(__always)
+    set {
+      self.__valid = newValue
+    }
+  }
+  
+  var sha256: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if bridge.has_value_std__optional_std__string_(self.__sha256) {
+          let __unwrapped = bridge.get_std__optional_std__string_(self.__sha256)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__sha256 = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var reason: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if bridge.has_value_std__optional_std__string_(self.__reason) {
+          let __unwrapped = bridge.get_std__optional_std__string_(self.__reason)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__reason = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+}

package/nitrogen/generated/ios/swift/VerifyGpgCleartextResult.swift

@@ -0,0 +1,96 @@
+///
+/// VerifyGpgCleartextResult.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2026 Marc Rousavy @ Margelo
+///
+
+import Foundation
+import NitroModules
+
+/**
+ * Represents an instance of `VerifyGpgCleartextResult`, backed by a C++ struct.
+ */
+public typealias VerifyGpgCleartextResult = margelo.nitro.reactnativebundlecrypto.VerifyGpgCleartextResult
+
+public extension VerifyGpgCleartextResult {
+  private typealias bridge = margelo.nitro.reactnativebundlecrypto.bridge.swift
+
+  /**
+   * Create a new instance of `VerifyGpgCleartextResult`.
+   */
+  init(valid: Bool, sha256: String?, reason: String?) {
+    self.init(valid, { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = sha256 {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = reason {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  var valid: Bool {
+    @inline(__always)
+    get {
+      return self.__valid
+    }
+    @inline(__always)
+    set {
+      self.__valid = newValue
+    }
+  }
+  
+  var sha256: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if bridge.has_value_std__optional_std__string_(self.__sha256) {
+          let __unwrapped = bridge.get_std__optional_std__string_(self.__sha256)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__sha256 = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+  
+  var reason: String? {
+    @inline(__always)
+    get {
+      return { () -> String? in
+        if bridge.has_value_std__optional_std__string_(self.__reason) {
+          let __unwrapped = bridge.get_std__optional_std__string_(self.__reason)
+          return String(__unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__reason = { () -> bridge.std__optional_std__string_ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
+}

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

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