react-native-quick-crypto 1.0.0-beta.9 → 1.0.1

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

@@ -2,7 +2,7 @@
 /// HybridRandomSpec.cpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2024 Marc Rousavy @ Margelo
+/// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
 #include "HybridRandomSpec.hpp"

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

@@ -2,7 +2,7 @@
 /// HybridRandomSpec.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2024 Marc Rousavy @ Margelo
+/// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -16,8 +16,8 @@
 // Forward declaration of `ArrayBuffer` to properly resolve imports.
 namespace NitroModules { class ArrayBuffer; }
 
-#include <NitroModules/Promise.hpp>
 #include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
 
 namespace margelo::nitro::crypto {
 
@@ -42,7 +42,7 @@ namespace margelo::nitro::crypto {
       explicit HybridRandomSpec(): HybridObject(TAG) { }
 
       // Destructor
-      virtual ~HybridRandomSpec() { }
+      ~HybridRandomSpec() override = default;
 
     public:
       // Properties

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

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

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

@@ -0,0 +1,72 @@
+///
+/// HybridRsaCipherSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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 `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+// Forward declaration of `HybridKeyObjectHandleSpec` to properly resolve imports.
+namespace margelo::nitro::crypto { class HybridKeyObjectHandleSpec; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include "HybridKeyObjectHandleSpec.hpp"
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `RsaCipher`
+   * Inherit this class to create instances of `HybridRsaCipherSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridRsaCipher: public HybridRsaCipherSpec {
+   * public:
+   *   HybridRsaCipher(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridRsaCipherSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridRsaCipherSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridRsaCipherSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<ArrayBuffer> encrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle, const std::shared_ptr<ArrayBuffer>& data, double padding, const std::string& hashAlgorithm, const std::optional<std::shared_ptr<ArrayBuffer>>& label) = 0;
+      virtual std::shared_ptr<ArrayBuffer> decrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle, const std::shared_ptr<ArrayBuffer>& data, double padding, const std::string& hashAlgorithm, const std::optional<std::shared_ptr<ArrayBuffer>>& label) = 0;
+      virtual std::shared_ptr<ArrayBuffer> privateEncrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle, const std::shared_ptr<ArrayBuffer>& data, double padding) = 0;
+      virtual std::shared_ptr<ArrayBuffer> privateDecrypt(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle, const std::shared_ptr<ArrayBuffer>& data, double padding) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "RsaCipher";
+  };
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,29 @@
+///
+/// HybridRsaKeyPairSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridRsaKeyPairSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  void HybridRsaKeyPairSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("generateKeyPair", &HybridRsaKeyPairSpec::generateKeyPair);
+      prototype.registerHybridMethod("generateKeyPairSync", &HybridRsaKeyPairSpec::generateKeyPairSync);
+      prototype.registerHybridMethod("setModulusLength", &HybridRsaKeyPairSpec::setModulusLength);
+      prototype.registerHybridMethod("setPublicExponent", &HybridRsaKeyPairSpec::setPublicExponent);
+      prototype.registerHybridMethod("setHashAlgorithm", &HybridRsaKeyPairSpec::setHashAlgorithm);
+      prototype.registerHybridMethod("importKey", &HybridRsaKeyPairSpec::importKey);
+      prototype.registerHybridMethod("exportKey", &HybridRsaKeyPairSpec::exportKey);
+      prototype.registerHybridMethod("getPublicKey", &HybridRsaKeyPairSpec::getPublicKey);
+      prototype.registerHybridMethod("getPrivateKey", &HybridRsaKeyPairSpec::getPrivateKey);
+    });
+  }
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,77 @@
+///
+/// HybridRsaKeyPairSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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 `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+// Forward declaration of `KeyObject` to properly resolve imports.
+namespace margelo::nitro::crypto { struct KeyObject; }
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <string>
+#include "KeyObject.hpp"
+#include <vector>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `RsaKeyPair`
+   * Inherit this class to create instances of `HybridRsaKeyPairSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridRsaKeyPair: public HybridRsaKeyPairSpec {
+   * public:
+   *   HybridRsaKeyPair(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridRsaKeyPairSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridRsaKeyPairSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridRsaKeyPairSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> generateKeyPair() = 0;
+      virtual void generateKeyPairSync() = 0;
+      virtual void setModulusLength(double modulusLength) = 0;
+      virtual void setPublicExponent(const std::shared_ptr<ArrayBuffer>& publicExponent) = 0;
+      virtual void setHashAlgorithm(const std::string& hashAlgorithm) = 0;
+      virtual KeyObject importKey(const std::string& format, const std::shared_ptr<ArrayBuffer>& keyData, const std::string& algorithm, bool extractable, const std::vector<std::string>& keyUsages) = 0;
+      virtual std::shared_ptr<ArrayBuffer> exportKey(const KeyObject& key, const std::string& format) = 0;
+      virtual std::shared_ptr<ArrayBuffer> getPublicKey() = 0;
+      virtual std::shared_ptr<ArrayBuffer> getPrivateKey() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "RsaKeyPair";
+  };
+
+} // namespace margelo::nitro::crypto

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

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

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

@@ -0,0 +1,71 @@
+///
+/// HybridSignHandleSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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 `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+// Forward declaration of `HybridKeyObjectHandleSpec` to properly resolve imports.
+namespace margelo::nitro::crypto { class HybridKeyObjectHandleSpec; }
+
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include "HybridKeyObjectHandleSpec.hpp"
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `SignHandle`
+   * Inherit this class to create instances of `HybridSignHandleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridSignHandle: public HybridSignHandleSpec {
+   * public:
+   *   HybridSignHandle(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridSignHandleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridSignHandleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridSignHandleSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void init(const std::string& algorithm) = 0;
+      virtual void update(const std::shared_ptr<ArrayBuffer>& data) = 0;
+      virtual std::shared_ptr<ArrayBuffer> sign(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle, std::optional<double> padding, std::optional<double> saltLength, std::optional<double> dsaEncoding) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "SignHandle";
+  };
+
+} // namespace margelo::nitro::crypto

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

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

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

@@ -0,0 +1,71 @@
+///
+/// HybridVerifyHandleSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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 `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+// Forward declaration of `HybridKeyObjectHandleSpec` to properly resolve imports.
+namespace margelo::nitro::crypto { class HybridKeyObjectHandleSpec; }
+
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <memory>
+#include "HybridKeyObjectHandleSpec.hpp"
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `VerifyHandle`
+   * Inherit this class to create instances of `HybridVerifyHandleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridVerifyHandle: public HybridVerifyHandleSpec {
+   * public:
+   *   HybridVerifyHandle(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridVerifyHandleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridVerifyHandleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridVerifyHandleSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void init(const std::string& algorithm) = 0;
+      virtual void update(const std::shared_ptr<ArrayBuffer>& data) = 0;
+      virtual bool verify(const std::shared_ptr<HybridKeyObjectHandleSpec>& keyHandle, const std::shared_ptr<ArrayBuffer>& signature, std::optional<double> padding, std::optional<double> saltLength, std::optional<double> dsaEncoding) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "VerifyHandle";
+  };
+
+} // namespace margelo::nitro::crypto

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

@@ -2,7 +2,7 @@
 /// JWK.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2024 Marc Rousavy @ Margelo
+/// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -25,11 +25,11 @@ namespace margelo::nitro::crypto { enum class JWKuse; }
 // Forward declaration of `KeyUsage` to properly resolve imports.
 namespace margelo::nitro::crypto { enum class KeyUsage; }
 
-#include <optional>
 #include "JWKkty.hpp"
+#include <optional>
 #include "JWKuse.hpp"
-#include <vector>
 #include "KeyUsage.hpp"
+#include <vector>
 #include <string>
 
 namespace margelo::nitro::crypto {
@@ -63,6 +63,7 @@ namespace margelo::nitro::crypto {
     std::optional<bool> ext     SWIFT_PRIVATE;
 
   public:
+    JWK() = default;
     explicit JWK(std::optional<JWKkty> kty, std::optional<JWKuse> use, std::optional<std::vector<KeyUsage>> key_ops, std::optional<std::string> alg, std::optional<std::string> crv, std::optional<std::string> kid, std::optional<std::string> x5u, std::optional<std::vector<std::string>> x5c, std::optional<std::string> x5t, std::optional<std::string> x5t_256, std::optional<std::string> n, std::optional<std::string> e, std::optional<std::string> d, std::optional<std::string> p, std::optional<std::string> q, std::optional<std::string> x, std::optional<std::string> y, std::optional<std::string> k, std::optional<std::string> dp, std::optional<std::string> dq, std::optional<std::string> qi, std::optional<bool> ext): kty(kty), use(use), key_ops(key_ops), alg(alg), crv(crv), kid(kid), x5u(x5u), x5c(x5c), x5t(x5t), x5t_256(x5t_256), n(n), e(e), d(d), p(p), q(q), x(x), y(y), k(k), dp(dp), dq(dq), qi(qi), ext(ext) {}
   };
 
@@ -70,17 +71,15 @@ namespace margelo::nitro::crypto {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ JWK <> JS JWK (object)
   template <>
-  struct JSIConverter<JWK> {
-    static inline JWK fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::crypto::JWK> final {
+    static inline margelo::nitro::crypto::JWK fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return JWK(
-        JSIConverter<std::optional<JWKkty>>::fromJSI(runtime, obj.getProperty(runtime, "kty")),
-        JSIConverter<std::optional<JWKuse>>::fromJSI(runtime, obj.getProperty(runtime, "use")),
-        JSIConverter<std::optional<std::vector<KeyUsage>>>::fromJSI(runtime, obj.getProperty(runtime, "key_ops")),
+      return margelo::nitro::crypto::JWK(
+        JSIConverter<std::optional<margelo::nitro::crypto::JWKkty>>::fromJSI(runtime, obj.getProperty(runtime, "kty")),
+        JSIConverter<std::optional<margelo::nitro::crypto::JWKuse>>::fromJSI(runtime, obj.getProperty(runtime, "use")),
+        JSIConverter<std::optional<std::vector<margelo::nitro::crypto::KeyUsage>>>::fromJSI(runtime, obj.getProperty(runtime, "key_ops")),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "alg")),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "crv")),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "kid")),
@@ -102,11 +101,11 @@ namespace margelo::nitro {
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, "ext"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const JWK& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::crypto::JWK& arg) {
       jsi::Object obj(runtime);
-      obj.setProperty(runtime, "kty", JSIConverter<std::optional<JWKkty>>::toJSI(runtime, arg.kty));
-      obj.setProperty(runtime, "use", JSIConverter<std::optional<JWKuse>>::toJSI(runtime, arg.use));
-      obj.setProperty(runtime, "key_ops", JSIConverter<std::optional<std::vector<KeyUsage>>>::toJSI(runtime, arg.key_ops));
+      obj.setProperty(runtime, "kty", JSIConverter<std::optional<margelo::nitro::crypto::JWKkty>>::toJSI(runtime, arg.kty));
+      obj.setProperty(runtime, "use", JSIConverter<std::optional<margelo::nitro::crypto::JWKuse>>::toJSI(runtime, arg.use));
+      obj.setProperty(runtime, "key_ops", JSIConverter<std::optional<std::vector<margelo::nitro::crypto::KeyUsage>>>::toJSI(runtime, arg.key_ops));
       obj.setProperty(runtime, "alg", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.alg));
       obj.setProperty(runtime, "crv", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.crv));
       obj.setProperty(runtime, "kid", JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.kid));
@@ -133,9 +132,9 @@ namespace margelo::nitro {
         return false;
       }
       jsi::Object obj = value.getObject(runtime);
-      if (!JSIConverter<std::optional<JWKkty>>::canConvert(runtime, obj.getProperty(runtime, "kty"))) return false;
-      if (!JSIConverter<std::optional<JWKuse>>::canConvert(runtime, obj.getProperty(runtime, "use"))) return false;
-      if (!JSIConverter<std::optional<std::vector<KeyUsage>>>::canConvert(runtime, obj.getProperty(runtime, "key_ops"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::crypto::JWKkty>>::canConvert(runtime, obj.getProperty(runtime, "kty"))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::crypto::JWKuse>>::canConvert(runtime, obj.getProperty(runtime, "use"))) return false;
+      if (!JSIConverter<std::optional<std::vector<margelo::nitro::crypto::KeyUsage>>>::canConvert(runtime, obj.getProperty(runtime, "key_ops"))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "alg"))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "crv"))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, "kid"))) return false;

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

@@ -2,7 +2,7 @@
 /// JWKkty.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2024 Marc Rousavy @ Margelo
+/// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -39,28 +39,26 @@ namespace margelo::nitro::crypto {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ JWKkty <> JS JWKkty (union)
   template <>
-  struct JSIConverter<JWKkty> {
-    static inline JWKkty fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::crypto::JWKkty> final {
+    static inline margelo::nitro::crypto::JWKkty 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("AES"): return JWKkty::AES;
-        case hashString("RSA"): return JWKkty::RSA;
-        case hashString("EC"): return JWKkty::EC;
-        case hashString("oct"): return JWKkty::OCT;
+        case hashString("AES"): return margelo::nitro::crypto::JWKkty::AES;
+        case hashString("RSA"): return margelo::nitro::crypto::JWKkty::RSA;
+        case hashString("EC"): return margelo::nitro::crypto::JWKkty::EC;
+        case hashString("oct"): return margelo::nitro::crypto::JWKkty::OCT;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum JWKkty - invalid value!");
       }
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, JWKkty arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::JWKkty arg) {
       switch (arg) {
-        case JWKkty::AES: return JSIConverter<std::string>::toJSI(runtime, "AES");
-        case JWKkty::RSA: return JSIConverter<std::string>::toJSI(runtime, "RSA");
-        case JWKkty::EC: return JSIConverter<std::string>::toJSI(runtime, "EC");
-        case JWKkty::OCT: return JSIConverter<std::string>::toJSI(runtime, "oct");
+        case margelo::nitro::crypto::JWKkty::AES: return JSIConverter<std::string>::toJSI(runtime, "AES");
+        case margelo::nitro::crypto::JWKkty::RSA: return JSIConverter<std::string>::toJSI(runtime, "RSA");
+        case margelo::nitro::crypto::JWKkty::EC: return JSIConverter<std::string>::toJSI(runtime, "EC");
+        case margelo::nitro::crypto::JWKkty::OCT: return JSIConverter<std::string>::toJSI(runtime, "oct");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert JWKkty to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");

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

@@ -2,7 +2,7 @@
 /// JWKuse.hpp
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
 /// https://github.com/mrousavy/nitro
-/// Copyright © 2024 Marc Rousavy @ Margelo
+/// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -37,24 +37,22 @@ namespace margelo::nitro::crypto {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ JWKuse <> JS JWKuse (union)
   template <>
-  struct JSIConverter<JWKuse> {
-    static inline JWKuse fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::crypto::JWKuse> final {
+    static inline margelo::nitro::crypto::JWKuse 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("sig"): return JWKuse::SIG;
-        case hashString("enc"): return JWKuse::ENC;
+        case hashString("sig"): return margelo::nitro::crypto::JWKuse::SIG;
+        case hashString("enc"): return margelo::nitro::crypto::JWKuse::ENC;
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum JWKuse - invalid value!");
       }
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, JWKuse arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::JWKuse arg) {
       switch (arg) {
-        case JWKuse::SIG: return JSIConverter<std::string>::toJSI(runtime, "sig");
-        case JWKuse::ENC: return JSIConverter<std::string>::toJSI(runtime, "enc");
+        case margelo::nitro::crypto::JWKuse::SIG: return JSIConverter<std::string>::toJSI(runtime, "sig");
+        case margelo::nitro::crypto::JWKuse::ENC: return JSIConverter<std::string>::toJSI(runtime, "enc");
         default: [[unlikely]]
           throw std::invalid_argument("Cannot convert JWKuse to JS - invalid value: "
                                     + std::to_string(static_cast<int>(arg)) + "!");