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

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

@@ -0,0 +1,74 @@
+///
+/// HybridHashSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridHashSpec` to properly resolve imports.
+namespace margelo::nitro::crypto { class HybridHashSpec; }
+
+#include <string>
+#include <optional>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <variant>
+#include <memory>
+#include "HybridHashSpec.hpp"
+#include <vector>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Hash`
+   * Inherit this class to create instances of `HybridHashSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridHash: public HybridHashSpec {
+   * public:
+   *   HybridHash(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridHashSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridHashSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridHashSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void createHash(const std::string& algorithm, std::optional<double> outputLength) = 0;
+      virtual void update(const std::variant<std::shared_ptr<ArrayBuffer>, std::string>& data) = 0;
+      virtual std::shared_ptr<ArrayBuffer> digest(const std::optional<std::string>& encoding) = 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
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Hash";
+  };
+
+} // namespace margelo::nitro::crypto

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

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

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

@@ -0,0 +1,67 @@
+///
+/// HybridHkdfSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HkdfMode` to properly resolve imports.
+namespace margelo::nitro::crypto { enum class HkdfMode; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <string>
+#include "HkdfMode.hpp"
+#include <NitroModules/Promise.hpp>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Hkdf`
+   * Inherit this class to create instances of `HybridHkdfSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridHkdf: public HybridHkdfSpec {
+   * public:
+   *   HybridHkdf(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridHkdfSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridHkdfSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridHkdfSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<ArrayBuffer> deriveKeySync(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& key, const std::shared_ptr<ArrayBuffer>& salt, const std::shared_ptr<ArrayBuffer>& info, double length, HkdfMode mode) = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> deriveKey(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& key, const std::shared_ptr<ArrayBuffer>& salt, const std::shared_ptr<ArrayBuffer>& info, double length, HkdfMode mode) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Hkdf";
+  };
+
+} // namespace margelo::nitro::crypto

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

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

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

@@ -0,0 +1,66 @@
+///
+/// HybridHmacSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <variant>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Hmac`
+   * Inherit this class to create instances of `HybridHmacSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridHmac: public HybridHmacSpec {
+   * public:
+   *   HybridHmac(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridHmacSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridHmacSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridHmacSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void createHmac(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& key) = 0;
+      virtual void update(const std::variant<std::shared_ptr<ArrayBuffer>, std::string>& data) = 0;
+      virtual std::shared_ptr<ArrayBuffer> digest() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Hmac";
+  };
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,39 @@
+///
+/// HybridKeyObjectHandleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridKeyObjectHandleSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  void HybridKeyObjectHandleSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("exportKey", &HybridKeyObjectHandleSpec::exportKey);
+      prototype.registerHybridMethod("exportJwk", &HybridKeyObjectHandleSpec::exportJwk);
+      prototype.registerHybridMethod("exportRawPublic", &HybridKeyObjectHandleSpec::exportRawPublic);
+      prototype.registerHybridMethod("exportRawPrivate", &HybridKeyObjectHandleSpec::exportRawPrivate);
+      prototype.registerHybridMethod("exportRawSeed", &HybridKeyObjectHandleSpec::exportRawSeed);
+      prototype.registerHybridMethod("exportECPublicRaw", &HybridKeyObjectHandleSpec::exportECPublicRaw);
+      prototype.registerHybridMethod("exportECPrivateRaw", &HybridKeyObjectHandleSpec::exportECPrivateRaw);
+      prototype.registerHybridMethod("getAsymmetricKeyType", &HybridKeyObjectHandleSpec::getAsymmetricKeyType);
+      prototype.registerHybridMethod("init", &HybridKeyObjectHandleSpec::init);
+      prototype.registerHybridMethod("initECRaw", &HybridKeyObjectHandleSpec::initECRaw);
+      prototype.registerHybridMethod("initPqcRaw", &HybridKeyObjectHandleSpec::initPqcRaw);
+      prototype.registerHybridMethod("initRawPublic", &HybridKeyObjectHandleSpec::initRawPublic);
+      prototype.registerHybridMethod("initRawPrivate", &HybridKeyObjectHandleSpec::initRawPrivate);
+      prototype.registerHybridMethod("initRawSeed", &HybridKeyObjectHandleSpec::initRawSeed);
+      prototype.registerHybridMethod("initJwk", &HybridKeyObjectHandleSpec::initJwk);
+      prototype.registerHybridMethod("keyDetail", &HybridKeyObjectHandleSpec::keyDetail);
+      prototype.registerHybridMethod("keyEquals", &HybridKeyObjectHandleSpec::keyEquals);
+      prototype.registerHybridMethod("getSymmetricKeySize", &HybridKeyObjectHandleSpec::getSymmetricKeySize);
+      prototype.registerHybridMethod("checkEcKeyData", &HybridKeyObjectHandleSpec::checkEcKeyData);
+    });
+  }
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,107 @@
+///
+/// HybridKeyObjectHandleSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `KFormatType` to properly resolve imports.
+namespace margelo::nitro::crypto { enum class KFormatType; }
+// Forward declaration of `KeyEncoding` to properly resolve imports.
+namespace margelo::nitro::crypto { enum class KeyEncoding; }
+// Forward declaration of `JWK` to properly resolve imports.
+namespace margelo::nitro::crypto { struct JWK; }
+// Forward declaration of `AsymmetricKeyType` to properly resolve imports.
+namespace margelo::nitro::crypto { enum class AsymmetricKeyType; }
+// Forward declaration of `KeyType` to properly resolve imports.
+namespace margelo::nitro::crypto { enum class KeyType; }
+// Forward declaration of `NamedCurve` to properly resolve imports.
+namespace margelo::nitro::crypto { enum class NamedCurve; }
+// Forward declaration of `KeyDetail` to properly resolve imports.
+namespace margelo::nitro::crypto { struct KeyDetail; }
+// Forward declaration of `HybridKeyObjectHandleSpec` to properly resolve imports.
+namespace margelo::nitro::crypto { class HybridKeyObjectHandleSpec; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include "KFormatType.hpp"
+#include <optional>
+#include "KeyEncoding.hpp"
+#include <string>
+#include "JWK.hpp"
+#include "AsymmetricKeyType.hpp"
+#include "KeyType.hpp"
+#include <variant>
+#include "NamedCurve.hpp"
+#include "KeyDetail.hpp"
+#include <memory>
+#include "HybridKeyObjectHandleSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `KeyObjectHandle`
+   * Inherit this class to create instances of `HybridKeyObjectHandleSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridKeyObjectHandle: public HybridKeyObjectHandleSpec {
+   * public:
+   *   HybridKeyObjectHandle(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridKeyObjectHandleSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridKeyObjectHandleSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridKeyObjectHandleSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<ArrayBuffer> exportKey(std::optional<KFormatType> format, std::optional<KeyEncoding> type, const std::optional<std::string>& cipher, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) = 0;
+      virtual JWK exportJwk(const JWK& key, bool handleRsaPss) = 0;
+      virtual std::shared_ptr<ArrayBuffer> exportRawPublic() = 0;
+      virtual std::shared_ptr<ArrayBuffer> exportRawPrivate() = 0;
+      virtual std::shared_ptr<ArrayBuffer> exportRawSeed() = 0;
+      virtual std::shared_ptr<ArrayBuffer> exportECPublicRaw(bool compressed) = 0;
+      virtual std::shared_ptr<ArrayBuffer> exportECPrivateRaw() = 0;
+      virtual AsymmetricKeyType getAsymmetricKeyType() = 0;
+      virtual bool init(KeyType keyType, const std::variant<std::shared_ptr<ArrayBuffer>, std::string>& key, std::optional<KFormatType> format, std::optional<KeyEncoding> type, const std::optional<std::shared_ptr<ArrayBuffer>>& passphrase) = 0;
+      virtual bool initECRaw(const std::string& namedCurve, const std::shared_ptr<ArrayBuffer>& keyData) = 0;
+      virtual bool initPqcRaw(const std::string& algorithmName, const std::shared_ptr<ArrayBuffer>& keyData, bool isPublic) = 0;
+      virtual bool initRawPublic(const std::string& asymmetricKeyType, const std::shared_ptr<ArrayBuffer>& keyData, const std::optional<std::string>& namedCurve) = 0;
+      virtual bool initRawPrivate(const std::string& asymmetricKeyType, const std::shared_ptr<ArrayBuffer>& keyData, const std::optional<std::string>& namedCurve) = 0;
+      virtual bool initRawSeed(const std::string& asymmetricKeyType, const std::shared_ptr<ArrayBuffer>& keyData) = 0;
+      virtual std::optional<KeyType> initJwk(const JWK& keyData, std::optional<NamedCurve> namedCurve) = 0;
+      virtual KeyDetail keyDetail() = 0;
+      virtual bool keyEquals(const std::shared_ptr<HybridKeyObjectHandleSpec>& other) = 0;
+      virtual double getSymmetricKeySize() = 0;
+      virtual bool checkEcKeyData() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "KeyObjectHandle";
+  };
+
+} // namespace margelo::nitro::crypto

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

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

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

@@ -0,0 +1,66 @@
+///
+/// HybridKmacSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Kmac`
+   * Inherit this class to create instances of `HybridKmacSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridKmac: public HybridKmacSpec {
+   * public:
+   *   HybridKmac(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridKmacSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridKmacSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridKmacSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void createKmac(const std::string& algorithm, const std::shared_ptr<ArrayBuffer>& key, double outputLength, const std::optional<std::shared_ptr<ArrayBuffer>>& customization) = 0;
+      virtual void update(const std::shared_ptr<ArrayBuffer>& data) = 0;
+      virtual std::shared_ptr<ArrayBuffer> digest() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Kmac";
+  };
+
+} // namespace margelo::nitro::crypto

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

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

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

@@ -0,0 +1,72 @@
+///
+/// HybridMlDsaKeyPairSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+
+
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
+#include <string>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `MlDsaKeyPair`
+   * Inherit this class to create instances of `HybridMlDsaKeyPairSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridMlDsaKeyPair: public HybridMlDsaKeyPairSpec {
+   * public:
+   *   HybridMlDsaKeyPair(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridMlDsaKeyPairSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridMlDsaKeyPairSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridMlDsaKeyPairSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<Promise<void>> generateKeyPair(double publicFormat, double publicType, double privateFormat, double privateType) = 0;
+      virtual void generateKeyPairSync(double publicFormat, double publicType, double privateFormat, double privateType) = 0;
+      virtual std::shared_ptr<ArrayBuffer> getPublicKey() = 0;
+      virtual std::shared_ptr<ArrayBuffer> getPrivateKey() = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> sign(const std::shared_ptr<ArrayBuffer>& message) = 0;
+      virtual std::shared_ptr<ArrayBuffer> signSync(const std::shared_ptr<ArrayBuffer>& message) = 0;
+      virtual std::shared_ptr<Promise<bool>> verify(const std::shared_ptr<ArrayBuffer>& signature, const std::shared_ptr<ArrayBuffer>& message) = 0;
+      virtual bool verifySync(const std::shared_ptr<ArrayBuffer>& signature, const std::shared_ptr<ArrayBuffer>& message) = 0;
+      virtual void setVariant(const std::string& variant) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "MlDsaKeyPair";
+  };
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,31 @@
+///
+/// HybridMlKemKeyPairSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridMlKemKeyPairSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  void HybridMlKemKeyPairSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridMethod("setVariant", &HybridMlKemKeyPairSpec::setVariant);
+      prototype.registerHybridMethod("generateKeyPair", &HybridMlKemKeyPairSpec::generateKeyPair);
+      prototype.registerHybridMethod("generateKeyPairSync", &HybridMlKemKeyPairSpec::generateKeyPairSync);
+      prototype.registerHybridMethod("getPublicKey", &HybridMlKemKeyPairSpec::getPublicKey);
+      prototype.registerHybridMethod("getPrivateKey", &HybridMlKemKeyPairSpec::getPrivateKey);
+      prototype.registerHybridMethod("setPublicKey", &HybridMlKemKeyPairSpec::setPublicKey);
+      prototype.registerHybridMethod("setPrivateKey", &HybridMlKemKeyPairSpec::setPrivateKey);
+      prototype.registerHybridMethod("encapsulate", &HybridMlKemKeyPairSpec::encapsulate);
+      prototype.registerHybridMethod("encapsulateSync", &HybridMlKemKeyPairSpec::encapsulateSync);
+      prototype.registerHybridMethod("decapsulate", &HybridMlKemKeyPairSpec::decapsulate);
+      prototype.registerHybridMethod("decapsulateSync", &HybridMlKemKeyPairSpec::decapsulateSync);
+    });
+  }
+
+} // namespace margelo::nitro::crypto