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

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

@@ -0,0 +1,76 @@
+///
+/// HybridCipherSpec.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 `CipherArgs` to properly resolve imports.
+namespace margelo::nitro::crypto { struct CipherArgs; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include "CipherArgs.hpp"
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Cipher`
+   * Inherit this class to create instances of `HybridCipherSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCipher: public HybridCipherSpec {
+   * public:
+   *   HybridCipher(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCipherSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCipherSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCipherSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<ArrayBuffer> update(const std::shared_ptr<ArrayBuffer>& data) = 0;
+      virtual std::shared_ptr<ArrayBuffer> final() = 0;
+      virtual void setArgs(const CipherArgs& args) = 0;
+      virtual bool setAAD(const std::shared_ptr<ArrayBuffer>& data, std::optional<double> plaintextLength) = 0;
+      virtual bool setAutoPadding(bool autoPad) = 0;
+      virtual bool setAuthTag(const std::shared_ptr<ArrayBuffer>& tag) = 0;
+      virtual std::shared_ptr<ArrayBuffer> getAuthTag() = 0;
+      virtual std::vector<std::string> getSupportedCiphers() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Cipher";
+  };
+
+} // 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

@@ -0,0 +1,30 @@
+///
+/// HybridEdKeyPairSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#include "HybridEdKeyPairSpec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  void HybridEdKeyPairSpec::loadHybridMethods() {
+    // load base methods/properties
+    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);
+      prototype.registerHybridMethod("getPrivateKey", &HybridEdKeyPairSpec::getPrivateKey);
+      prototype.registerHybridMethod("sign", &HybridEdKeyPairSpec::sign);
+      prototype.registerHybridMethod("signSync", &HybridEdKeyPairSpec::signSync);
+      prototype.registerHybridMethod("verify", &HybridEdKeyPairSpec::verify);
+      prototype.registerHybridMethod("verifySync", &HybridEdKeyPairSpec::verifySync);
+      prototype.registerHybridMethod("setCurve", &HybridEdKeyPairSpec::setCurve);
+    });
+  }
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,75 @@
+///
+/// HybridEdKeyPairSpec.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; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <NitroModules/Promise.hpp>
+#include <string>
+#include <optional>
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `EdKeyPair`
+   * Inherit this class to create instances of `HybridEdKeyPairSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridEdKeyPair: public HybridEdKeyPairSpec {
+   * public:
+   *   HybridEdKeyPair(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridEdKeyPairSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridEdKeyPairSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridEdKeyPairSpec() override = default;
+
+    public:
+      // Properties
+      
+
+    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;
+      virtual std::shared_ptr<ArrayBuffer> getPrivateKey() = 0;
+      virtual std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> sign(const std::shared_ptr<ArrayBuffer>& message, const std::optional<std::shared_ptr<ArrayBuffer>>& key) = 0;
+      virtual std::shared_ptr<ArrayBuffer> signSync(const std::shared_ptr<ArrayBuffer>& message, const std::optional<std::shared_ptr<ArrayBuffer>>& key) = 0;
+      virtual std::shared_ptr<Promise<bool>> verify(const std::shared_ptr<ArrayBuffer>& signature, const std::shared_ptr<ArrayBuffer>& message, const std::optional<std::shared_ptr<ArrayBuffer>>& key) = 0;
+      virtual bool verifySync(const std::shared_ptr<ArrayBuffer>& signature, const std::shared_ptr<ArrayBuffer>& message, const std::optional<std::shared_ptr<ArrayBuffer>>& key) = 0;
+      virtual void setCurve(const std::string& curve) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "EdKeyPair";
+  };
+
+} // namespace margelo::nitro::crypto

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

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

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

@@ -0,0 +1,75 @@
+///
+/// HybridHashSpec.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 `HybridHashSpec` to properly resolve imports.
+namespace margelo::nitro::crypto { class HybridHashSpec; }
+
+#include <string>
+#include <optional>
+#include <NitroModules/ArrayBuffer.hpp>
+#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::shared_ptr<ArrayBuffer>& 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++/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 © 2025 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 © 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; }
+
+#include <string>
+#include <NitroModules/ArrayBuffer.hpp>
+
+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::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 = "Hmac";
+  };
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,26 @@
+///
+/// HybridKeyObjectHandleSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 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("getAsymmetricKeyType", &HybridKeyObjectHandleSpec::getAsymmetricKeyType);
+      prototype.registerHybridMethod("init", &HybridKeyObjectHandleSpec::init);
+      prototype.registerHybridMethod("initJwk", &HybridKeyObjectHandleSpec::initJwk);
+      prototype.registerHybridMethod("keyDetail", &HybridKeyObjectHandleSpec::keyDetail);
+    });
+  }
+
+} // namespace margelo::nitro::crypto

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

@@ -0,0 +1,92 @@
+///
+/// HybridKeyObjectHandleSpec.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 `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 `CFRGKeyPairType` to properly resolve imports.
+namespace margelo::nitro::crypto { enum class CFRGKeyPairType; }
+// 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; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include "KFormatType.hpp"
+#include <optional>
+#include "KeyEncoding.hpp"
+#include <string>
+#include "JWK.hpp"
+#include "CFRGKeyPairType.hpp"
+#include "KeyType.hpp"
+#include <variant>
+#include "NamedCurve.hpp"
+#include "KeyDetail.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 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 std::optional<KeyType> initJwk(const JWK& keyData, std::optional<NamedCurve> namedCurve) = 0;
+      virtual KeyDetail keyDetail() = 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++/HybridPbkdf2Spec.cpp

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