react-native-quick-crypto 1.0.0-beta.20 → 1.0.0-beta.21

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

@@ -53,7 +53,7 @@ namespace margelo::nitro::crypto {
 
     public:
       // Methods
-      virtual std::shared_ptr<margelo::nitro::crypto::HybridCipherSpec> createCipher(const CipherArgs& args) = 0;
+      virtual std::shared_ptr<HybridCipherSpec> createCipher(const CipherArgs& args) = 0;
 
     protected:
       // Hybrid Setup

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

@@ -21,8 +21,8 @@ namespace margelo::nitro::crypto { struct CipherArgs; }
 #include <NitroModules/ArrayBuffer.hpp>
 #include "CipherArgs.hpp"
 #include <optional>
-#include <vector>
 #include <string>
+#include <vector>
 
 namespace margelo::nitro::crypto {
 

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

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

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

@@ -0,0 +1,77 @@
+///
+/// HybridEcKeyPairSpec.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 `KeyObject` to properly resolve imports.
+namespace margelo::nitro::crypto { struct KeyObject; }
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+
+#include <NitroModules/Promise.hpp>
+#include "KeyObject.hpp"
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <vector>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `EcKeyPair`
+   * Inherit this class to create instances of `HybridEcKeyPairSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridEcKeyPair: public HybridEcKeyPairSpec {
+   * public:
+   *   HybridEcKeyPair(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridEcKeyPairSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridEcKeyPairSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridEcKeyPairSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> generateKeyPair() = 0;
+      virtual void generateKeyPairSync() = 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;
+      virtual void setCurve(const std::string& curve) = 0;
+      virtual std::shared_ptr<ArrayBuffer> sign(const std::shared_ptr<ArrayBuffer>& data, const std::string& hashAlgorithm) = 0;
+      virtual bool verify(const std::shared_ptr<ArrayBuffer>& data, const std::shared_ptr<ArrayBuffer>& signature, const std::string& hashAlgorithm) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "EcKeyPair";
+  };
+
+} // namespace margelo::nitro::crypto

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

@@ -14,6 +14,7 @@ namespace margelo::nitro::crypto {
     HybridObject::loadHybridMethods();
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("diffieHellman", &HybridEdKeyPairSpec::diffieHellman);
       prototype.registerHybridMethod("generateKeyPair", &HybridEdKeyPairSpec::generateKeyPair);
       prototype.registerHybridMethod("generateKeyPairSync", &HybridEdKeyPairSpec::generateKeyPairSync);
       prototype.registerHybridMethod("getPublicKey", &HybridEdKeyPairSpec::getPublicKey);

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

@@ -16,10 +16,10 @@
 // Forward declaration of `ArrayBuffer` to properly resolve imports.
 namespace NitroModules { class ArrayBuffer; }
 
+#include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/Promise.hpp>
-#include <optional>
 #include <string>
-#include <NitroModules/ArrayBuffer.hpp>
+#include <optional>
 
 namespace margelo::nitro::crypto {
 
@@ -52,6 +52,7 @@ namespace margelo::nitro::crypto {
 
     public:
       // Methods
+      virtual std::shared_ptr<ArrayBuffer> diffieHellman(const std::shared_ptr<ArrayBuffer>& privateKey, const std::shared_ptr<ArrayBuffer>& publicKey) = 0;
       virtual std::shared_ptr<Promise<void>> generateKeyPair(double publicFormat, double publicType, double privateFormat, double privateType, const std::optional<std::string>& cipher, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) = 0;
       virtual void generateKeyPairSync(double publicFormat, double publicType, double privateFormat, double privateType, const std::optional<std::string>& cipher, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) = 0;
       virtual std::shared_ptr<ArrayBuffer> getPublicKey() = 0;

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

@@ -19,6 +19,7 @@ namespace margelo::nitro::crypto {
       prototype.registerHybridMethod("digest", &HybridHashSpec::digest);
       prototype.registerHybridMethod("copy", &HybridHashSpec::copy);
       prototype.registerHybridMethod("getSupportedHashAlgorithms", &HybridHashSpec::getSupportedHashAlgorithms);
+      prototype.registerHybridMethod("getOpenSSLVersion", &HybridHashSpec::getOpenSSLVersion);
     });
   }
 

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

@@ -59,8 +59,9 @@ namespace margelo::nitro::crypto {
       virtual void createHash(const std::string& algorithm, std::optional<double> outputLength) = 0;
       virtual void update(const std::shared_ptr<ArrayBuffer>& data) = 0;
       virtual std::shared_ptr<ArrayBuffer> digest(const std::optional<std::string>& encoding) = 0;
-      virtual std::shared_ptr<margelo::nitro::crypto::HybridHashSpec> copy(std::optional<double> outputLength) = 0;
+      virtual std::shared_ptr<HybridHashSpec> copy(std::optional<double> outputLength) = 0;
       virtual std::vector<std::string> getSupportedHashAlgorithms() = 0;
+      virtual std::string getOpenSSLVersion() = 0;
 
     protected:
       // Hybrid Setup

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

@@ -18,7 +18,6 @@ namespace margelo::nitro::crypto {
       prototype.registerHybridMethod("exportJwk", &HybridKeyObjectHandleSpec::exportJwk);
       prototype.registerHybridMethod("getAsymmetricKeyType", &HybridKeyObjectHandleSpec::getAsymmetricKeyType);
       prototype.registerHybridMethod("init", &HybridKeyObjectHandleSpec::init);
-      prototype.registerHybridMethod("initECRaw", &HybridKeyObjectHandleSpec::initECRaw);
       prototype.registerHybridMethod("initJwk", &HybridKeyObjectHandleSpec::initJwk);
       prototype.registerHybridMethod("keyDetail", &HybridKeyObjectHandleSpec::keyDetail);
     });

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

@@ -31,8 +31,8 @@ namespace margelo::nitro::crypto { enum class NamedCurve; }
 namespace margelo::nitro::crypto { struct KeyDetail; }
 
 #include <NitroModules/ArrayBuffer.hpp>
-#include <optional>
 #include "KFormatType.hpp"
+#include <optional>
 #include "KeyEncoding.hpp"
 #include <string>
 #include "JWK.hpp"
@@ -77,7 +77,6 @@ namespace margelo::nitro::crypto {
       virtual JWK exportJwk(const JWK& key, bool handleRsaPss) = 0;
       virtual CFRGKeyPairType getAsymmetricKeyType() = 0;
       virtual bool init(KeyType keyType, const std::variant<std::string, std::shared_ptr<ArrayBuffer>>& key, std::optional<KFormatType> format, std::optional<KeyEncoding> type, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) = 0;
-      virtual bool initECRaw(const std::string& curveName, const std::shared_ptr<ArrayBuffer>& keyData) = 0;
       virtual std::optional<KeyType> initJwk(const JWK& keyData, std::optional<NamedCurve> namedCurve) = 0;
       virtual KeyDetail keyDetail() = 0;
 

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

@@ -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>
 #include <string>
 
 namespace margelo::nitro::crypto {

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

@@ -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 {
 

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++/JWK.hpp

@@ -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 {
@@ -71,17 +71,15 @@ namespace margelo::nitro::crypto {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ JWK <> JS JWK (object)
   template <>
-  struct JSIConverter<JWK> final {
-    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")),
@@ -103,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));
@@ -134,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

@@ -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> final {
-    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

@@ -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> final {
-    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)) + "!");

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

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include <cmath>
 #if __has_include(<NitroModules/JSIConverter.hpp>)
 #include <NitroModules/JSIConverter.hpp>
 #else
@@ -25,25 +24,23 @@ namespace margelo::nitro::crypto {
    * An enum which can be represented as a JavaScript enum (KFormatType).
    */
   enum class KFormatType {
-    KKEYFORMATDER      SWIFT_NAME(kkeyformatder) = 0,
-    KKEYFORMATPEM      SWIFT_NAME(kkeyformatpem) = 1,
-    KKEYFORMATJWK      SWIFT_NAME(kkeyformatjwk) = 2,
+    DER      SWIFT_NAME(der) = 0,
+    PEM      SWIFT_NAME(pem) = 1,
+    JWK      SWIFT_NAME(jwk) = 2,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::crypto
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ KFormatType <> JS KFormatType (enum)
   template <>
-  struct JSIConverter<KFormatType> final {
-    static inline KFormatType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::crypto::KFormatType> final {
+    static inline margelo::nitro::crypto::KFormatType fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
-      return static_cast<KFormatType>(enumValue);
+      return static_cast<margelo::nitro::crypto::KFormatType>(enumValue);
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, KFormatType arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::KFormatType arg) {
       int enumValue = static_cast<int>(arg);
       return JSIConverter<int>::toJSI(runtime, enumValue);
     }
@@ -51,10 +48,11 @@ namespace margelo::nitro {
       if (!value.isNumber()) {
         return false;
       }
-      double integer;
-      double fraction = modf(value.getNumber(), &integer);
-      if (fraction != 0.0) {
-        // It is some kind of floating point number - our enums are ints.
+      double number = value.getNumber();
+      int integer = static_cast<int>(number);
+      if (number != integer) {
+        // The integer is not the same value as the double - we truncated floating points.
+        // Enums are all integers, so the input floating point number is obviously invalid.
         return false;
       }
       // Check if we are within the bounds of the enum.

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

@@ -47,14 +47,12 @@ namespace margelo::nitro::crypto {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ KeyDetail <> JS KeyDetail (object)
   template <>
-  struct JSIConverter<KeyDetail> final {
-    static inline KeyDetail fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::crypto::KeyDetail> final {
+    static inline margelo::nitro::crypto::KeyDetail fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       jsi::Object obj = arg.asObject(runtime);
-      return KeyDetail(
+      return margelo::nitro::crypto::KeyDetail(
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "length")),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "publicExponent")),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "modulusLength")),
@@ -64,7 +62,7 @@ namespace margelo::nitro {
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, "namedCurve"))
       );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, const KeyDetail& arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::crypto::KeyDetail& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, "length", JSIConverter<std::optional<double>>::toJSI(runtime, arg.length));
       obj.setProperty(runtime, "publicExponent", JSIConverter<std::optional<double>>::toJSI(runtime, arg.publicExponent));

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

@@ -7,7 +7,6 @@
 
 #pragma once
 
-#include <cmath>
 #if __has_include(<NitroModules/JSIConverter.hpp>)
 #include <NitroModules/JSIConverter.hpp>
 #else
@@ -25,26 +24,24 @@ namespace margelo::nitro::crypto {
    * An enum which can be represented as a JavaScript enum (KeyEncoding).
    */
   enum class KeyEncoding {
-    KKEYENCODINGPKCS1      SWIFT_NAME(kkeyencodingpkcs1) = 0,
-    KKEYENCODINGPKCS8      SWIFT_NAME(kkeyencodingpkcs8) = 1,
-    KKEYENCODINGSPKI      SWIFT_NAME(kkeyencodingspki) = 2,
-    KKEYENCODINGSEC1      SWIFT_NAME(kkeyencodingsec1) = 3,
+    PKCS1      SWIFT_NAME(pkcs1) = 0,
+    PKCS8      SWIFT_NAME(pkcs8) = 1,
+    SPKI      SWIFT_NAME(spki) = 2,
+    SEC1      SWIFT_NAME(sec1) = 3,
   } CLOSED_ENUM;
 
 } // namespace margelo::nitro::crypto
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ KeyEncoding <> JS KeyEncoding (enum)
   template <>
-  struct JSIConverter<KeyEncoding> final {
-    static inline KeyEncoding fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+  struct JSIConverter<margelo::nitro::crypto::KeyEncoding> final {
+    static inline margelo::nitro::crypto::KeyEncoding fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
       int enumValue = JSIConverter<int>::fromJSI(runtime, arg);
-      return static_cast<KeyEncoding>(enumValue);
+      return static_cast<margelo::nitro::crypto::KeyEncoding>(enumValue);
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, KeyEncoding arg) {
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::KeyEncoding arg) {
       int enumValue = static_cast<int>(arg);
       return JSIConverter<int>::toJSI(runtime, enumValue);
     }
@@ -52,10 +49,11 @@ namespace margelo::nitro {
       if (!value.isNumber()) {
         return false;
       }
-      double integer;
-      double fraction = modf(value.getNumber(), &integer);
-      if (fraction != 0.0) {
-        // It is some kind of floating point number - our enums are ints.
+      double number = value.getNumber();
+      int integer = static_cast<int>(number);
+      if (number != integer) {
+        // The integer is not the same value as the double - we truncated floating points.
+        // Enums are all integers, so the input floating point number is obviously invalid.
         return false;
       }
       // Check if we are within the bounds of the enum.