@onekeyfe/react-native-image 3.0.98

package/nitrogen/generated/ios/swift/OneKeyImageLoadingStrategy.swift

@@ -0,0 +1,44 @@
+///
+/// OneKeyImageLoadingStrategy.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `OneKeyImageLoadingStrategy`, backed by a C++ enum.
+ */
+public typealias OneKeyImageLoadingStrategy = margelo.nitro.onekeyimage.OneKeyImageLoadingStrategy
+
+public extension OneKeyImageLoadingStrategy {
+  /**
+   * Get a OneKeyImageLoadingStrategy for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "static":
+        self = .static
+      case "skeleton":
+        self = .skeleton
+      case "none":
+        self = .none
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this OneKeyImageLoadingStrategy represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .static:
+        return "static"
+      case .skeleton:
+        return "skeleton"
+      case .none:
+        return "none"
+    }
+  }
+}

package/nitrogen/generated/ios/swift/OneKeyImagePreloadSource.swift

@@ -0,0 +1,148 @@
+///
+/// OneKeyImagePreloadSource.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/**
+ * Represents an instance of `OneKeyImagePreloadSource`, backed by a C++ struct.
+ */
+public typealias OneKeyImagePreloadSource = margelo.nitro.onekeyimage.OneKeyImagePreloadSource
+
+public extension OneKeyImagePreloadSource {
+  private typealias bridge = margelo.nitro.onekeyimage.bridge.swift
+
+  /**
+   * Create a new instance of `OneKeyImagePreloadSource`.
+   */
+  init(uri: String, headersJson: String?, cachePolicy: OneKeyImageCachePolicy?, resizeWidth: Double?, resizeHeight: Double?, pixelRatio: Double?, overscan: Double?, optimizeTos: Bool?) {
+    self.init(std.string(uri), { () -> bridge.std__optional_std__string_ in
+      if let __unwrappedValue = headersJson {
+        return bridge.create_std__optional_std__string_(std.string(__unwrappedValue))
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_OneKeyImageCachePolicy_ in
+      if let __unwrappedValue = cachePolicy {
+        return bridge.create_std__optional_OneKeyImageCachePolicy_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = resizeWidth {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = resizeHeight {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = pixelRatio {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_double_ in
+      if let __unwrappedValue = overscan {
+        return bridge.create_std__optional_double_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }(), { () -> bridge.std__optional_bool_ in
+      if let __unwrappedValue = optimizeTos {
+        return bridge.create_std__optional_bool_(__unwrappedValue)
+      } else {
+        return .init()
+      }
+    }())
+  }
+
+  @inline(__always)
+  var uri: String {
+    return String(self.__uri)
+  }
+  
+  @inline(__always)
+  var headersJson: String? {
+    return { () -> String? in
+      if bridge.has_value_std__optional_std__string_(self.__headersJson) {
+        let __unwrapped = bridge.get_std__optional_std__string_(self.__headersJson)
+        return String(__unwrapped)
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var cachePolicy: OneKeyImageCachePolicy? {
+    return self.__cachePolicy.value
+  }
+  
+  @inline(__always)
+  var resizeWidth: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__resizeWidth) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__resizeWidth)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var resizeHeight: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__resizeHeight) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__resizeHeight)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var pixelRatio: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__pixelRatio) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__pixelRatio)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var overscan: Double? {
+    return { () -> Double? in
+      if bridge.has_value_std__optional_double_(self.__overscan) {
+        let __unwrapped = bridge.get_std__optional_double_(self.__overscan)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+  
+  @inline(__always)
+  var optimizeTos: Bool? {
+    return { () -> Bool? in
+      if bridge.has_value_std__optional_bool_(self.__optimizeTos) {
+        let __unwrapped = bridge.get_std__optional_bool_(self.__optimizeTos)
+        return __unwrapped
+      } else {
+        return nil
+      }
+    }()
+  }
+}

package/nitrogen/generated/ios/swift/OneKeyImageVariant.swift

@@ -0,0 +1,48 @@
+///
+/// OneKeyImageVariant.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+/**
+ * Represents the JS union `OneKeyImageVariant`, backed by a C++ enum.
+ */
+public typealias OneKeyImageVariant = margelo.nitro.onekeyimage.OneKeyImageVariant
+
+public extension OneKeyImageVariant {
+  /**
+   * Get a OneKeyImageVariant for the given String value, or
+   * return `nil` if the given value was invalid/unknown.
+   */
+  init?(fromString string: String) {
+    switch string {
+      case "generic":
+        self = .generic
+      case "token":
+        self = .token
+      case "network":
+        self = .network
+      case "avatar":
+        self = .avatar
+      default:
+        return nil
+    }
+  }
+
+  /**
+   * Get the String value this OneKeyImageVariant represents.
+   */
+  var stringValue: String {
+    switch self {
+      case .generic:
+        return "generic"
+      case .token:
+        return "token"
+      case .network:
+        return "network"
+      case .avatar:
+        return "avatar"
+    }
+  }
+}

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

@@ -0,0 +1,24 @@
+///
+/// HybridOneKeyImageCacheSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridOneKeyImageCacheSpec.hpp"
+
+namespace margelo::nitro::onekeyimage {
+
+  void HybridOneKeyImageCacheSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("preload", &HybridOneKeyImageCacheSpec::preload);
+      prototype.registerHybridMethod("clearMemory", &HybridOneKeyImageCacheSpec::clearMemory);
+      prototype.registerHybridMethod("clearDisk", &HybridOneKeyImageCacheSpec::clearDisk);
+      prototype.registerHybridMethod("clearAll", &HybridOneKeyImageCacheSpec::clearAll);
+    });
+  }
+
+} // namespace margelo::nitro::onekeyimage

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

@@ -0,0 +1,68 @@
+///
+/// HybridOneKeyImageCacheSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `OneKeyImagePreloadSource` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { struct OneKeyImagePreloadSource; }
+
+#include <NitroModules/Promise.hpp>
+#include "OneKeyImagePreloadSource.hpp"
+#include <vector>
+
+namespace margelo::nitro::onekeyimage {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `OneKeyImageCache`
+   * Inherit this class to create instances of `HybridOneKeyImageCacheSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridOneKeyImageCache: public HybridOneKeyImageCacheSpec {
+   * public:
+   *   HybridOneKeyImageCache(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridOneKeyImageCacheSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridOneKeyImageCacheSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridOneKeyImageCacheSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<bool>> preload(const std::vector<OneKeyImagePreloadSource>& sources) = 0;
+      virtual std::shared_ptr<Promise<void>> clearMemory() = 0;
+      virtual std::shared_ptr<Promise<void>> clearDisk() = 0;
+      virtual std::shared_ptr<Promise<void>> clearAll() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "OneKeyImageCache";
+  };
+
+} // namespace margelo::nitro::onekeyimage

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

@@ -0,0 +1,52 @@
+///
+/// HybridOneKeyImageSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridOneKeyImageSpec.hpp"
+
+namespace margelo::nitro::onekeyimage {
+
+  void HybridOneKeyImageSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("sourceUri", &HybridOneKeyImageSpec::getSourceUri);
+      prototype.registerHybridSetter("sourceUri", &HybridOneKeyImageSpec::setSourceUri);
+      prototype.registerHybridGetter("sourceHeadersJson", &HybridOneKeyImageSpec::getSourceHeadersJson);
+      prototype.registerHybridSetter("sourceHeadersJson", &HybridOneKeyImageSpec::setSourceHeadersJson);
+      prototype.registerHybridGetter("variant", &HybridOneKeyImageSpec::getVariant);
+      prototype.registerHybridSetter("variant", &HybridOneKeyImageSpec::setVariant);
+      prototype.registerHybridGetter("contentFit", &HybridOneKeyImageSpec::getContentFit);
+      prototype.registerHybridSetter("contentFit", &HybridOneKeyImageSpec::setContentFit);
+      prototype.registerHybridGetter("cachePolicy", &HybridOneKeyImageSpec::getCachePolicy);
+      prototype.registerHybridSetter("cachePolicy", &HybridOneKeyImageSpec::setCachePolicy);
+      prototype.registerHybridGetter("autoplay", &HybridOneKeyImageSpec::getAutoplay);
+      prototype.registerHybridSetter("autoplay", &HybridOneKeyImageSpec::setAutoplay);
+      prototype.registerHybridGetter("recyclingKey", &HybridOneKeyImageSpec::getRecyclingKey);
+      prototype.registerHybridSetter("recyclingKey", &HybridOneKeyImageSpec::setRecyclingKey);
+      prototype.registerHybridGetter("optimizeTos", &HybridOneKeyImageSpec::getOptimizeTos);
+      prototype.registerHybridSetter("optimizeTos", &HybridOneKeyImageSpec::setOptimizeTos);
+      prototype.registerHybridGetter("overscan", &HybridOneKeyImageSpec::getOverscan);
+      prototype.registerHybridSetter("overscan", &HybridOneKeyImageSpec::setOverscan);
+      prototype.registerHybridGetter("loadingStrategy", &HybridOneKeyImageSpec::getLoadingStrategy);
+      prototype.registerHybridSetter("loadingStrategy", &HybridOneKeyImageSpec::setLoadingStrategy);
+      prototype.registerHybridGetter("onLoadStart", &HybridOneKeyImageSpec::getOnLoadStart);
+      prototype.registerHybridSetter("onLoadStart", &HybridOneKeyImageSpec::setOnLoadStart);
+      prototype.registerHybridGetter("onLoad", &HybridOneKeyImageSpec::getOnLoad);
+      prototype.registerHybridSetter("onLoad", &HybridOneKeyImageSpec::setOnLoad);
+      prototype.registerHybridGetter("onDisplay", &HybridOneKeyImageSpec::getOnDisplay);
+      prototype.registerHybridSetter("onDisplay", &HybridOneKeyImageSpec::setOnDisplay);
+      prototype.registerHybridGetter("onError", &HybridOneKeyImageSpec::getOnError);
+      prototype.registerHybridSetter("onError", &HybridOneKeyImageSpec::setOnError);
+      prototype.registerHybridGetter("onLoadEnd", &HybridOneKeyImageSpec::getOnLoadEnd);
+      prototype.registerHybridSetter("onLoadEnd", &HybridOneKeyImageSpec::setOnLoadEnd);
+      prototype.registerHybridMethod("reload", &HybridOneKeyImageSpec::reload);
+      prototype.registerHybridMethod("cancel", &HybridOneKeyImageSpec::cancel);
+    });
+  }
+
+} // namespace margelo::nitro::onekeyimage

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

@@ -0,0 +1,108 @@
+///
+/// HybridOneKeyImageSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `OneKeyImageVariant` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageVariant; }
+// Forward declaration of `OneKeyImageContentFit` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageContentFit; }
+// Forward declaration of `OneKeyImageCachePolicy` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageCachePolicy; }
+// Forward declaration of `OneKeyImageLoadingStrategy` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageLoadingStrategy; }
+// Forward declaration of `OneKeyImageCacheType` to properly resolve imports.
+namespace margelo::nitro::onekeyimage { enum class OneKeyImageCacheType; }
+
+#include <string>
+#include <optional>
+#include "OneKeyImageVariant.hpp"
+#include "OneKeyImageContentFit.hpp"
+#include "OneKeyImageCachePolicy.hpp"
+#include "OneKeyImageLoadingStrategy.hpp"
+#include <functional>
+#include "OneKeyImageCacheType.hpp"
+
+namespace margelo::nitro::onekeyimage {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `OneKeyImage`
+   * Inherit this class to create instances of `HybridOneKeyImageSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridOneKeyImage: public HybridOneKeyImageSpec {
+   * public:
+   *   HybridOneKeyImage(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridOneKeyImageSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridOneKeyImageSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridOneKeyImageSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::optional<std::string> getSourceUri() = 0;
+      virtual void setSourceUri(const std::optional<std::string>& sourceUri) = 0;
+      virtual std::optional<std::string> getSourceHeadersJson() = 0;
+      virtual void setSourceHeadersJson(const std::optional<std::string>& sourceHeadersJson) = 0;
+      virtual std::optional<OneKeyImageVariant> getVariant() = 0;
+      virtual void setVariant(std::optional<OneKeyImageVariant> variant) = 0;
+      virtual std::optional<OneKeyImageContentFit> getContentFit() = 0;
+      virtual void setContentFit(std::optional<OneKeyImageContentFit> contentFit) = 0;
+      virtual std::optional<OneKeyImageCachePolicy> getCachePolicy() = 0;
+      virtual void setCachePolicy(std::optional<OneKeyImageCachePolicy> cachePolicy) = 0;
+      virtual std::optional<bool> getAutoplay() = 0;
+      virtual void setAutoplay(std::optional<bool> autoplay) = 0;
+      virtual std::optional<std::string> getRecyclingKey() = 0;
+      virtual void setRecyclingKey(const std::optional<std::string>& recyclingKey) = 0;
+      virtual std::optional<bool> getOptimizeTos() = 0;
+      virtual void setOptimizeTos(std::optional<bool> optimizeTos) = 0;
+      virtual std::optional<double> getOverscan() = 0;
+      virtual void setOverscan(std::optional<double> overscan) = 0;
+      virtual std::optional<OneKeyImageLoadingStrategy> getLoadingStrategy() = 0;
+      virtual void setLoadingStrategy(std::optional<OneKeyImageLoadingStrategy> loadingStrategy) = 0;
+      virtual std::optional<std::function<void()>> getOnLoadStart() = 0;
+      virtual void setOnLoadStart(const std::optional<std::function<void()>>& onLoadStart) = 0;
+      virtual std::optional<std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>> getOnLoad() = 0;
+      virtual void setOnLoad(const std::optional<std::function<void(double /* width */, double /* height */, OneKeyImageCacheType /* cacheType */)>>& onLoad) = 0;
+      virtual std::optional<std::function<void()>> getOnDisplay() = 0;
+      virtual void setOnDisplay(const std::optional<std::function<void()>>& onDisplay) = 0;
+      virtual std::optional<std::function<void(const std::string& /* message */)>> getOnError() = 0;
+      virtual void setOnError(const std::optional<std::function<void(const std::string& /* message */)>>& onError) = 0;
+      virtual std::optional<std::function<void()>> getOnLoadEnd() = 0;
+      virtual void setOnLoadEnd(const std::optional<std::function<void()>>& onLoadEnd) = 0;
+
+    public:
+      // Methods
+      virtual void reload() = 0;
+      virtual void cancel() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "OneKeyImage";
+  };
+
+} // namespace margelo::nitro::onekeyimage

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

@@ -0,0 +1,84 @@
+///
+/// OneKeyImageCachePolicy.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#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
+
+namespace margelo::nitro::onekeyimage {
+
+  /**
+   * An enum which can be represented as a JavaScript union (OneKeyImageCachePolicy).
+   */
+  enum class OneKeyImageCachePolicy {
+    MEMORY_DISK      SWIFT_NAME(memoryDisk) = 0,
+    MEMORY      SWIFT_NAME(memory) = 1,
+    DISK      SWIFT_NAME(disk) = 2,
+    NONE      SWIFT_NAME(none) = 3,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::onekeyimage
+
+namespace margelo::nitro {
+
+  // C++ OneKeyImageCachePolicy <> JS OneKeyImageCachePolicy (union)
+  template <>
+  struct JSIConverter<margelo::nitro::onekeyimage::OneKeyImageCachePolicy> final {
+    static inline margelo::nitro::onekeyimage::OneKeyImageCachePolicy fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("memory-disk"): return margelo::nitro::onekeyimage::OneKeyImageCachePolicy::MEMORY_DISK;
+        case hashString("memory"): return margelo::nitro::onekeyimage::OneKeyImageCachePolicy::MEMORY;
+        case hashString("disk"): return margelo::nitro::onekeyimage::OneKeyImageCachePolicy::DISK;
+        case hashString("none"): return margelo::nitro::onekeyimage::OneKeyImageCachePolicy::NONE;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum OneKeyImageCachePolicy - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::onekeyimage::OneKeyImageCachePolicy arg) {
+      switch (arg) {
+        case margelo::nitro::onekeyimage::OneKeyImageCachePolicy::MEMORY_DISK: return JSIConverter<std::string>::toJSI(runtime, "memory-disk");
+        case margelo::nitro::onekeyimage::OneKeyImageCachePolicy::MEMORY: return JSIConverter<std::string>::toJSI(runtime, "memory");
+        case margelo::nitro::onekeyimage::OneKeyImageCachePolicy::DISK: return JSIConverter<std::string>::toJSI(runtime, "disk");
+        case margelo::nitro::onekeyimage::OneKeyImageCachePolicy::NONE: return JSIConverter<std::string>::toJSI(runtime, "none");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert OneKeyImageCachePolicy to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("memory-disk"):
+        case hashString("memory"):
+        case hashString("disk"):
+        case hashString("none"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,80 @@
+///
+/// OneKeyImageCacheType.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/NitroHash.hpp>)
+#include <NitroModules/NitroHash.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#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
+
+namespace margelo::nitro::onekeyimage {
+
+  /**
+   * An enum which can be represented as a JavaScript union (OneKeyImageCacheType).
+   */
+  enum class OneKeyImageCacheType {
+    NONE      SWIFT_NAME(none) = 0,
+    MEMORY      SWIFT_NAME(memory) = 1,
+    DISK      SWIFT_NAME(disk) = 2,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::onekeyimage
+
+namespace margelo::nitro {
+
+  // C++ OneKeyImageCacheType <> JS OneKeyImageCacheType (union)
+  template <>
+  struct JSIConverter<margelo::nitro::onekeyimage::OneKeyImageCacheType> final {
+    static inline margelo::nitro::onekeyimage::OneKeyImageCacheType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("none"): return margelo::nitro::onekeyimage::OneKeyImageCacheType::NONE;
+        case hashString("memory"): return margelo::nitro::onekeyimage::OneKeyImageCacheType::MEMORY;
+        case hashString("disk"): return margelo::nitro::onekeyimage::OneKeyImageCacheType::DISK;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum OneKeyImageCacheType - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::onekeyimage::OneKeyImageCacheType arg) {
+      switch (arg) {
+        case margelo::nitro::onekeyimage::OneKeyImageCacheType::NONE: return JSIConverter<std::string>::toJSI(runtime, "none");
+        case margelo::nitro::onekeyimage::OneKeyImageCacheType::MEMORY: return JSIConverter<std::string>::toJSI(runtime, "memory");
+        case margelo::nitro::onekeyimage::OneKeyImageCacheType::DISK: return JSIConverter<std::string>::toJSI(runtime, "disk");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert OneKeyImageCacheType to JS - invalid value: "
+                                    + std::to_string(static_cast<int>(arg)) + "!");
+      }
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isString()) {
+        return false;
+      }
+      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
+      switch (hashString(unionValue.c_str(), unionValue.size())) {
+        case hashString("none"):
+        case hashString("memory"):
+        case hashString("disk"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro