@ohos-ports/react-native-quick-crypto 0.0.0-stage → 1.1.8-beta.0

package/nitrogen/generated/ios/QuickCryptoAutolinking.mm

@@ -0,0 +1,325 @@
+///
+/// QuickCryptoAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+
+#import <type_traits>
+
+#include "HybridArgon2.hpp"
+#include "HybridBlake3.hpp"
+#include "HybridCertificate.hpp"
+#include "HybridCipher.hpp"
+#include "HybridCipherFactory.hpp"
+#include "HybridDhKeyPair.hpp"
+#include "HybridDiffieHellman.hpp"
+#include "HybridDsaKeyPair.hpp"
+#include "HybridECDH.hpp"
+#include "HybridEcKeyPair.hpp"
+#include "HybridEdKeyPair.hpp"
+#include "HybridHash.hpp"
+#include "HybridHkdf.hpp"
+#include "HybridHmac.hpp"
+#include "HybridKmac.hpp"
+#include "HybridKeyObjectHandle.hpp"
+#include "HybridMlDsaKeyPair.hpp"
+#include "HybridMlKemKeyPair.hpp"
+#include "HybridSlhDsaKeyPair.hpp"
+#include "HybridPbkdf2.hpp"
+#include "HybridPrime.hpp"
+#include "HybridRandom.hpp"
+#include "HybridRsaCipher.hpp"
+#include "HybridRsaKeyPair.hpp"
+#include "HybridScrypt.hpp"
+#include "HybridSignHandle.hpp"
+#include "HybridTurboShake.hpp"
+#include "HybridUtils.hpp"
+#include "HybridVerifyHandle.hpp"
+#include "HybridX509Certificate.hpp"
+
+@interface QuickCryptoAutolinking : NSObject
+@end
+
+@implementation QuickCryptoAutolinking
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::crypto;
+
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Argon2",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridArgon2>,
+                    "The HybridObject \"HybridArgon2\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridArgon2>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Blake3",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridBlake3>,
+                    "The HybridObject \"HybridBlake3\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridBlake3>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Certificate",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCertificate>,
+                    "The HybridObject \"HybridCertificate\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCertificate>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Cipher",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCipher>,
+                    "The HybridObject \"HybridCipher\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCipher>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "CipherFactory",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridCipherFactory>,
+                    "The HybridObject \"HybridCipherFactory\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridCipherFactory>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "DhKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridDhKeyPair>,
+                    "The HybridObject \"HybridDhKeyPair\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridDhKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "DiffieHellman",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridDiffieHellman>,
+                    "The HybridObject \"HybridDiffieHellman\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridDiffieHellman>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "DsaKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridDsaKeyPair>,
+                    "The HybridObject \"HybridDsaKeyPair\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridDsaKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "ECDH",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridECDH>,
+                    "The HybridObject \"HybridECDH\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridECDH>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "EcKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridEcKeyPair>,
+                    "The HybridObject \"HybridEcKeyPair\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridEcKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "EdKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridEdKeyPair>,
+                    "The HybridObject \"HybridEdKeyPair\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridEdKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Hash",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridHash>,
+                    "The HybridObject \"HybridHash\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridHash>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Hkdf",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridHkdf>,
+                    "The HybridObject \"HybridHkdf\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridHkdf>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Hmac",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridHmac>,
+                    "The HybridObject \"HybridHmac\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridHmac>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Kmac",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridKmac>,
+                    "The HybridObject \"HybridKmac\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridKmac>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "KeyObjectHandle",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridKeyObjectHandle>,
+                    "The HybridObject \"HybridKeyObjectHandle\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridKeyObjectHandle>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MlDsaKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridMlDsaKeyPair>,
+                    "The HybridObject \"HybridMlDsaKeyPair\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridMlDsaKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "MlKemKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridMlKemKeyPair>,
+                    "The HybridObject \"HybridMlKemKeyPair\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridMlKemKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "SlhDsaKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridSlhDsaKeyPair>,
+                    "The HybridObject \"HybridSlhDsaKeyPair\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridSlhDsaKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Pbkdf2",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridPbkdf2>,
+                    "The HybridObject \"HybridPbkdf2\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridPbkdf2>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Prime",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridPrime>,
+                    "The HybridObject \"HybridPrime\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridPrime>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Random",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridRandom>,
+                    "The HybridObject \"HybridRandom\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridRandom>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "RsaCipher",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridRsaCipher>,
+                    "The HybridObject \"HybridRsaCipher\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridRsaCipher>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "RsaKeyPair",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridRsaKeyPair>,
+                    "The HybridObject \"HybridRsaKeyPair\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridRsaKeyPair>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Scrypt",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridScrypt>,
+                    "The HybridObject \"HybridScrypt\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridScrypt>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "SignHandle",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridSignHandle>,
+                    "The HybridObject \"HybridSignHandle\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridSignHandle>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "TurboShake",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridTurboShake>,
+                    "The HybridObject \"HybridTurboShake\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridTurboShake>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "Utils",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridUtils>,
+                    "The HybridObject \"HybridUtils\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridUtils>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "VerifyHandle",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridVerifyHandle>,
+                    "The HybridObject \"HybridVerifyHandle\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridVerifyHandle>();
+    }
+  );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "X509CertificateHandle",
+    []() -> std::shared_ptr<HybridObject> {
+      static_assert(std::is_default_constructible_v<HybridX509Certificate>,
+                    "The HybridObject \"HybridX509Certificate\" is not default-constructible! "
+                    "Create a public constructor that takes zero arguments to be able to autolink this HybridObject.");
+      return std::make_shared<HybridX509Certificate>();
+    }
+  );
+}
+
+@end

package/nitrogen/generated/ios/QuickCryptoAutolinking.swift

@@ -0,0 +1,16 @@
+///
+/// QuickCryptoAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+// TODO: Use empty enums once Swift supports exporting them as namespaces
+//       See: https://github.com/swiftlang/swift/pull/83616
+public final class QuickCryptoAutolinking {
+  public typealias bridge = margelo.nitro.crypto.bridge.swift
+
+  
+}

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

@@ -0,0 +1,176 @@
+///
+/// AsymmetricKeyType.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::crypto {
+
+  /**
+   * An enum which can be represented as a JavaScript union (AsymmetricKeyType).
+   */
+  enum class AsymmetricKeyType {
+    RSA      SWIFT_NAME(rsa) = 0,
+    RSA_PSS      SWIFT_NAME(rsaPss) = 1,
+    DSA      SWIFT_NAME(dsa) = 2,
+    EC      SWIFT_NAME(ec) = 3,
+    DH      SWIFT_NAME(dh) = 4,
+    ED25519      SWIFT_NAME(ed25519) = 5,
+    ED448      SWIFT_NAME(ed448) = 6,
+    X25519      SWIFT_NAME(x25519) = 7,
+    X448      SWIFT_NAME(x448) = 8,
+    ML_DSA_44      SWIFT_NAME(mlDsa44) = 9,
+    ML_DSA_65      SWIFT_NAME(mlDsa65) = 10,
+    ML_DSA_87      SWIFT_NAME(mlDsa87) = 11,
+    ML_KEM_512      SWIFT_NAME(mlKem512) = 12,
+    ML_KEM_768      SWIFT_NAME(mlKem768) = 13,
+    ML_KEM_1024      SWIFT_NAME(mlKem1024) = 14,
+    SLH_DSA_SHA2_128S      SWIFT_NAME(slhDsaSha2128s) = 15,
+    SLH_DSA_SHA2_128F      SWIFT_NAME(slhDsaSha2128f) = 16,
+    SLH_DSA_SHA2_192S      SWIFT_NAME(slhDsaSha2192s) = 17,
+    SLH_DSA_SHA2_192F      SWIFT_NAME(slhDsaSha2192f) = 18,
+    SLH_DSA_SHA2_256S      SWIFT_NAME(slhDsaSha2256s) = 19,
+    SLH_DSA_SHA2_256F      SWIFT_NAME(slhDsaSha2256f) = 20,
+    SLH_DSA_SHAKE_128S      SWIFT_NAME(slhDsaShake128s) = 21,
+    SLH_DSA_SHAKE_128F      SWIFT_NAME(slhDsaShake128f) = 22,
+    SLH_DSA_SHAKE_192S      SWIFT_NAME(slhDsaShake192s) = 23,
+    SLH_DSA_SHAKE_192F      SWIFT_NAME(slhDsaShake192f) = 24,
+    SLH_DSA_SHAKE_256S      SWIFT_NAME(slhDsaShake256s) = 25,
+    SLH_DSA_SHAKE_256F      SWIFT_NAME(slhDsaShake256f) = 26,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::crypto
+
+namespace margelo::nitro {
+
+  // C++ AsymmetricKeyType <> JS AsymmetricKeyType (union)
+  template <>
+  struct JSIConverter<margelo::nitro::crypto::AsymmetricKeyType> final {
+    static inline margelo::nitro::crypto::AsymmetricKeyType 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("rsa"): return margelo::nitro::crypto::AsymmetricKeyType::RSA;
+        case hashString("rsa-pss"): return margelo::nitro::crypto::AsymmetricKeyType::RSA_PSS;
+        case hashString("dsa"): return margelo::nitro::crypto::AsymmetricKeyType::DSA;
+        case hashString("ec"): return margelo::nitro::crypto::AsymmetricKeyType::EC;
+        case hashString("dh"): return margelo::nitro::crypto::AsymmetricKeyType::DH;
+        case hashString("ed25519"): return margelo::nitro::crypto::AsymmetricKeyType::ED25519;
+        case hashString("ed448"): return margelo::nitro::crypto::AsymmetricKeyType::ED448;
+        case hashString("x25519"): return margelo::nitro::crypto::AsymmetricKeyType::X25519;
+        case hashString("x448"): return margelo::nitro::crypto::AsymmetricKeyType::X448;
+        case hashString("ml-dsa-44"): return margelo::nitro::crypto::AsymmetricKeyType::ML_DSA_44;
+        case hashString("ml-dsa-65"): return margelo::nitro::crypto::AsymmetricKeyType::ML_DSA_65;
+        case hashString("ml-dsa-87"): return margelo::nitro::crypto::AsymmetricKeyType::ML_DSA_87;
+        case hashString("ml-kem-512"): return margelo::nitro::crypto::AsymmetricKeyType::ML_KEM_512;
+        case hashString("ml-kem-768"): return margelo::nitro::crypto::AsymmetricKeyType::ML_KEM_768;
+        case hashString("ml-kem-1024"): return margelo::nitro::crypto::AsymmetricKeyType::ML_KEM_1024;
+        case hashString("slh-dsa-sha2-128s"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_128S;
+        case hashString("slh-dsa-sha2-128f"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_128F;
+        case hashString("slh-dsa-sha2-192s"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_192S;
+        case hashString("slh-dsa-sha2-192f"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_192F;
+        case hashString("slh-dsa-sha2-256s"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_256S;
+        case hashString("slh-dsa-sha2-256f"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_256F;
+        case hashString("slh-dsa-shake-128s"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_128S;
+        case hashString("slh-dsa-shake-128f"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_128F;
+        case hashString("slh-dsa-shake-192s"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_192S;
+        case hashString("slh-dsa-shake-192f"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_192F;
+        case hashString("slh-dsa-shake-256s"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_256S;
+        case hashString("slh-dsa-shake-256f"): return margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_256F;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum AsymmetricKeyType - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::AsymmetricKeyType arg) {
+      switch (arg) {
+        case margelo::nitro::crypto::AsymmetricKeyType::RSA: return JSIConverter<std::string>::toJSI(runtime, "rsa");
+        case margelo::nitro::crypto::AsymmetricKeyType::RSA_PSS: return JSIConverter<std::string>::toJSI(runtime, "rsa-pss");
+        case margelo::nitro::crypto::AsymmetricKeyType::DSA: return JSIConverter<std::string>::toJSI(runtime, "dsa");
+        case margelo::nitro::crypto::AsymmetricKeyType::EC: return JSIConverter<std::string>::toJSI(runtime, "ec");
+        case margelo::nitro::crypto::AsymmetricKeyType::DH: return JSIConverter<std::string>::toJSI(runtime, "dh");
+        case margelo::nitro::crypto::AsymmetricKeyType::ED25519: return JSIConverter<std::string>::toJSI(runtime, "ed25519");
+        case margelo::nitro::crypto::AsymmetricKeyType::ED448: return JSIConverter<std::string>::toJSI(runtime, "ed448");
+        case margelo::nitro::crypto::AsymmetricKeyType::X25519: return JSIConverter<std::string>::toJSI(runtime, "x25519");
+        case margelo::nitro::crypto::AsymmetricKeyType::X448: return JSIConverter<std::string>::toJSI(runtime, "x448");
+        case margelo::nitro::crypto::AsymmetricKeyType::ML_DSA_44: return JSIConverter<std::string>::toJSI(runtime, "ml-dsa-44");
+        case margelo::nitro::crypto::AsymmetricKeyType::ML_DSA_65: return JSIConverter<std::string>::toJSI(runtime, "ml-dsa-65");
+        case margelo::nitro::crypto::AsymmetricKeyType::ML_DSA_87: return JSIConverter<std::string>::toJSI(runtime, "ml-dsa-87");
+        case margelo::nitro::crypto::AsymmetricKeyType::ML_KEM_512: return JSIConverter<std::string>::toJSI(runtime, "ml-kem-512");
+        case margelo::nitro::crypto::AsymmetricKeyType::ML_KEM_768: return JSIConverter<std::string>::toJSI(runtime, "ml-kem-768");
+        case margelo::nitro::crypto::AsymmetricKeyType::ML_KEM_1024: return JSIConverter<std::string>::toJSI(runtime, "ml-kem-1024");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_128S: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-sha2-128s");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_128F: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-sha2-128f");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_192S: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-sha2-192s");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_192F: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-sha2-192f");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_256S: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-sha2-256s");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHA2_256F: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-sha2-256f");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_128S: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-shake-128s");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_128F: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-shake-128f");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_192S: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-shake-192s");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_192F: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-shake-192f");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_256S: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-shake-256s");
+        case margelo::nitro::crypto::AsymmetricKeyType::SLH_DSA_SHAKE_256F: return JSIConverter<std::string>::toJSI(runtime, "slh-dsa-shake-256f");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert AsymmetricKeyType 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("rsa"):
+        case hashString("rsa-pss"):
+        case hashString("dsa"):
+        case hashString("ec"):
+        case hashString("dh"):
+        case hashString("ed25519"):
+        case hashString("ed448"):
+        case hashString("x25519"):
+        case hashString("x448"):
+        case hashString("ml-dsa-44"):
+        case hashString("ml-dsa-65"):
+        case hashString("ml-dsa-87"):
+        case hashString("ml-kem-512"):
+        case hashString("ml-kem-768"):
+        case hashString("ml-kem-1024"):
+        case hashString("slh-dsa-sha2-128s"):
+        case hashString("slh-dsa-sha2-128f"):
+        case hashString("slh-dsa-sha2-192s"):
+        case hashString("slh-dsa-sha2-192f"):
+        case hashString("slh-dsa-sha2-256s"):
+        case hashString("slh-dsa-sha2-256f"):
+        case hashString("slh-dsa-shake-128s"):
+        case hashString("slh-dsa-shake-128f"):
+        case hashString("slh-dsa-shake-192s"):
+        case hashString("slh-dsa-shake-192f"):
+        case hashString("slh-dsa-shake-256s"):
+        case hashString("slh-dsa-shake-256f"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,101 @@
+///
+/// CipherArgs.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/JSIConverter.hpp>)
+#include <NitroModules/JSIConverter.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/NitroDefines.hpp>)
+#include <NitroModules/NitroDefines.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+  /**
+   * A struct which can be represented as a JavaScript object (CipherArgs).
+   */
+  struct CipherArgs final {
+  public:
+    bool isCipher     SWIFT_PRIVATE;
+    std::string cipherType     SWIFT_PRIVATE;
+    std::shared_ptr<ArrayBuffer> cipherKey     SWIFT_PRIVATE;
+    std::shared_ptr<ArrayBuffer> iv     SWIFT_PRIVATE;
+    std::optional<double> authTagLen     SWIFT_PRIVATE;
+
+  public:
+    CipherArgs() = default;
+    explicit CipherArgs(bool isCipher, std::string cipherType, std::shared_ptr<ArrayBuffer> cipherKey, std::shared_ptr<ArrayBuffer> iv, std::optional<double> authTagLen): isCipher(isCipher), cipherType(cipherType), cipherKey(cipherKey), iv(iv), authTagLen(authTagLen) {}
+
+  public:
+    friend bool operator==(const CipherArgs& lhs, const CipherArgs& rhs) = default;
+  };
+
+} // namespace margelo::nitro::crypto
+
+namespace margelo::nitro {
+
+  // C++ CipherArgs <> JS CipherArgs (object)
+  template <>
+  struct JSIConverter<margelo::nitro::crypto::CipherArgs> final {
+    static inline margelo::nitro::crypto::CipherArgs fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::crypto::CipherArgs(
+        JSIConverter<bool>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isCipher"))),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cipherType"))),
+        JSIConverter<std::shared_ptr<ArrayBuffer>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cipherKey"))),
+        JSIConverter<std::shared_ptr<ArrayBuffer>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "iv"))),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "authTagLen")))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::crypto::CipherArgs& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "isCipher"), JSIConverter<bool>::toJSI(runtime, arg.isCipher));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "cipherType"), JSIConverter<std::string>::toJSI(runtime, arg.cipherType));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "cipherKey"), JSIConverter<std::shared_ptr<ArrayBuffer>>::toJSI(runtime, arg.cipherKey));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "iv"), JSIConverter<std::shared_ptr<ArrayBuffer>>::toJSI(runtime, arg.iv));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "authTagLen"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.authTagLen));
+      return obj;
+    }
+    static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
+      if (!value.isObject()) {
+        return false;
+      }
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
+      }
+      if (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "isCipher")))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cipherType")))) return false;
+      if (!JSIConverter<std::shared_ptr<ArrayBuffer>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cipherKey")))) return false;
+      if (!JSIConverter<std::shared_ptr<ArrayBuffer>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "iv")))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "authTagLen")))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro