react-native-quick-crypto 1.0.0-beta.8 → 1.0.0

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

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

@@ -2,12 +2,11 @@
 /// KFormatType.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
 
-#include <cmath>
 #if __has_include(<NitroModules/JSIConverter.hpp>)
 #include <NitroModules/JSIConverter.hpp>
 #else
@@ -25,36 +24,35 @@ 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> {
-    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);
     }
-    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
       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

@@ -2,7 +2,7 @@
 /// KeyDetail.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,6 +39,7 @@ namespace margelo::nitro::crypto {
     std::optional<std::string> namedCurve     SWIFT_PRIVATE;
 
   public:
+    KeyDetail() = default;
     explicit KeyDetail(std::optional<double> length, std::optional<double> publicExponent, std::optional<double> modulusLength, std::optional<std::string> hashAlgorithm, std::optional<std::string> mgf1HashAlgorithm, std::optional<double> saltLength, std::optional<std::string> namedCurve): length(length), publicExponent(publicExponent), modulusLength(modulusLength), hashAlgorithm(hashAlgorithm), mgf1HashAlgorithm(mgf1HashAlgorithm), saltLength(saltLength), namedCurve(namedCurve) {}
   };
 
@@ -46,14 +47,12 @@ namespace margelo::nitro::crypto {
 
 namespace margelo::nitro {
 
-  using namespace margelo::nitro::crypto;
-
   // C++ KeyDetail <> JS KeyDetail (object)
   template <>
-  struct JSIConverter<KeyDetail> {
-    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")),
@@ -63,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

@@ -2,12 +2,11 @@
 /// KeyEncoding.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
 
-#include <cmath>
 #if __has_include(<NitroModules/JSIConverter.hpp>)
 #include <NitroModules/JSIConverter.hpp>
 #else
@@ -25,37 +24,36 @@ 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> {
-    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);
     }
-    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+    static inline bool canConvert(jsi::Runtime&, const jsi::Value& value) {
       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.