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

package/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Bridge.cpp

@@ -1,9 +1,17 @@
 ///
 /// QuickCrypto-Swift-Cxx-Bridge.cpp
-/// Tue Aug 13 2024
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/react-native-nitro
-/// Copyright © 2024 Marc Rousavy @ Margelo
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
 #include "QuickCrypto-Swift-Cxx-Bridge.hpp"
+
+// Include C++ implementation defined types
+
+
+namespace margelo::nitro::crypto::bridge::swift {
+
+  
+
+} // namespace margelo::nitro::crypto::bridge::swift

package/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Bridge.hpp

@@ -1,9 +1,8 @@
 ///
 /// QuickCrypto-Swift-Cxx-Bridge.hpp
-/// Tue Aug 13 2024
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/react-native-nitro
-/// Copyright © 2024 Marc Rousavy @ Margelo
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
 #pragma once
@@ -11,6 +10,9 @@
 // Forward declarations of C++ defined types
 
 
+// Forward declarations of Swift defined types
+
+
 // Include C++ defined types
 
 

package/nitrogen/generated/ios/QuickCrypto-Swift-Cxx-Umbrella.hpp

@@ -1,29 +1,38 @@
 ///
 /// QuickCrypto-Swift-Cxx-Umbrella.hpp
-/// Tue Aug 13 2024
 /// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/react-native-nitro
-/// Copyright © 2024 Marc Rousavy @ Margelo
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
 ///
 
 #pragma once
 
 // Forward declarations of C++ defined types
-// Forward declaration of `ArrayBuffer` to properly resolve imports.
-namespace NitroModules { class ArrayBuffer; }
+
 
 // Include C++ defined types
-#include <NitroModules/ArrayBuffer.hpp>
+
 
 // C++ helpers for Swift
 #include "QuickCrypto-Swift-Cxx-Bridge.hpp"
 
+// Common C++ types used in Swift
+#include <NitroModules/ArrayBufferHolder.hpp>
+#include <NitroModules/AnyMapUtils.hpp>
+#include <NitroModules/RuntimeError.hpp>
+#include <NitroModules/DateToChronoDate.hpp>
+
 // Forward declarations of Swift defined types
 
 
 // Include Swift defined types
 #if __has_include("QuickCrypto-Swift.h")
+// This header is generated by Xcode/Swift on every app build.
+// If it cannot be found, make sure the Swift module's name (= podspec name) is actually "QuickCrypto".
 #include "QuickCrypto-Swift.h"
+// Same as above, but used when building with frameworks (`use_frameworks`)
+#elif __has_include(<QuickCrypto/QuickCrypto-Swift.h>)
+#include <QuickCrypto/QuickCrypto-Swift.h>
 #else
-#error QuickCrypto's autogenerated Swift header cannot be found! Make sure the Swift module's name is actually "QuickCrypto", and try building the app first.
+#error QuickCrypto's autogenerated Swift header cannot be found! Make sure the Swift module's name (= podspec name) is actually "QuickCrypto", and try building the app first.
 #endif

package/nitrogen/generated/ios/QuickCryptoAutolinking.mm

@@ -0,0 +1,135 @@
+///
+/// QuickCryptoAutolinking.mm
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+#import <Foundation/Foundation.h>
+#import <NitroModules/HybridObjectRegistry.hpp>
+
+#import <type_traits>
+
+#include "HybridBlake3.hpp"
+#include "HybridCipher.hpp"
+#include "HybridCipherFactory.hpp"
+#include "HybridEcKeyPair.hpp"
+#include "HybridEdKeyPair.hpp"
+#include "HybridHash.hpp"
+#include "HybridHmac.hpp"
+#include "HybridKeyObjectHandle.hpp"
+#include "HybridPbkdf2.hpp"
+#include "HybridRandom.hpp"
+#include "HybridRsaKeyPair.hpp"
+
+@interface QuickCryptoAutolinking : NSObject
+@end
+
+@implementation QuickCryptoAutolinking
+
++ (void) load {
+  using namespace margelo::nitro;
+  using namespace margelo::nitro::crypto;
+
+  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(
+    "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(
+    "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(
+    "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(
+    "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(
+    "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(
+    "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(
+    "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>();
+    }
+  );
+}
+
+@end

package/nitrogen/generated/ios/QuickCryptoAutolinking.swift

@@ -0,0 +1,12 @@
+///
+/// QuickCryptoAutolinking.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © 2025 Marc Rousavy @ Margelo
+///
+
+public final class QuickCryptoAutolinking {
+  public typealias bridge = margelo.nitro.crypto.bridge.swift
+
+  
+}

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

@@ -0,0 +1,84 @@
+///
+/// CFRGKeyPairType.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/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 (CFRGKeyPairType).
+   */
+  enum class CFRGKeyPairType {
+    ED25519      SWIFT_NAME(ed25519) = 0,
+    ED448      SWIFT_NAME(ed448) = 1,
+    X25519      SWIFT_NAME(x25519) = 2,
+    X448      SWIFT_NAME(x448) = 3,
+  } CLOSED_ENUM;
+
+} // namespace margelo::nitro::crypto
+
+namespace margelo::nitro {
+
+  // C++ CFRGKeyPairType <> JS CFRGKeyPairType (union)
+  template <>
+  struct JSIConverter<margelo::nitro::crypto::CFRGKeyPairType> final {
+    static inline margelo::nitro::crypto::CFRGKeyPairType 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("ed25519"): return margelo::nitro::crypto::CFRGKeyPairType::ED25519;
+        case hashString("ed448"): return margelo::nitro::crypto::CFRGKeyPairType::ED448;
+        case hashString("x25519"): return margelo::nitro::crypto::CFRGKeyPairType::X25519;
+        case hashString("x448"): return margelo::nitro::crypto::CFRGKeyPairType::X448;
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum CFRGKeyPairType - invalid value!");
+      }
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::crypto::CFRGKeyPairType arg) {
+      switch (arg) {
+        case margelo::nitro::crypto::CFRGKeyPairType::ED25519: return JSIConverter<std::string>::toJSI(runtime, "ed25519");
+        case margelo::nitro::crypto::CFRGKeyPairType::ED448: return JSIConverter<std::string>::toJSI(runtime, "ed448");
+        case margelo::nitro::crypto::CFRGKeyPairType::X25519: return JSIConverter<std::string>::toJSI(runtime, "x25519");
+        case margelo::nitro::crypto::CFRGKeyPairType::X448: return JSIConverter<std::string>::toJSI(runtime, "x448");
+        default: [[unlikely]]
+          throw std::invalid_argument("Cannot convert CFRGKeyPairType 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("ed25519"):
+        case hashString("ed448"):
+        case hashString("x25519"):
+        case hashString("x448"):
+          return true;
+        default:
+          return false;
+      }
+    }
+  };
+
+} // namespace margelo::nitro

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

@@ -0,0 +1,86 @@
+///
+/// CipherArgs.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/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
+
+// Forward declaration of `ArrayBuffer` to properly resolve imports.
+namespace NitroModules { class ArrayBuffer; }
+
+#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 {
+  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) {}
+  };
+
+} // 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, "isCipher")),
+        JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "cipherType")),
+        JSIConverter<std::shared_ptr<ArrayBuffer>>::fromJSI(runtime, obj.getProperty(runtime, "cipherKey")),
+        JSIConverter<std::shared_ptr<ArrayBuffer>>::fromJSI(runtime, obj.getProperty(runtime, "iv")),
+        JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, "authTagLen"))
+      );
+    }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::crypto::CipherArgs& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, "isCipher", JSIConverter<bool>::toJSI(runtime, arg.isCipher));
+      obj.setProperty(runtime, "cipherType", JSIConverter<std::string>::toJSI(runtime, arg.cipherType));
+      obj.setProperty(runtime, "cipherKey", JSIConverter<std::shared_ptr<ArrayBuffer>>::toJSI(runtime, arg.cipherKey));
+      obj.setProperty(runtime, "iv", JSIConverter<std::shared_ptr<ArrayBuffer>>::toJSI(runtime, arg.iv));
+      obj.setProperty(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 (!JSIConverter<bool>::canConvert(runtime, obj.getProperty(runtime, "isCipher"))) return false;
+      if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "cipherType"))) return false;
+      if (!JSIConverter<std::shared_ptr<ArrayBuffer>>::canConvert(runtime, obj.getProperty(runtime, "cipherKey"))) return false;
+      if (!JSIConverter<std::shared_ptr<ArrayBuffer>>::canConvert(runtime, obj.getProperty(runtime, "iv"))) return false;
+      if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, "authTagLen"))) return false;
+      return true;
+    }
+  };
+
+} // namespace margelo::nitro

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

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

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

@@ -0,0 +1,76 @@
+///
+/// HybridBlake3Spec.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 `HybridBlake3Spec` to properly resolve imports.
+namespace margelo::nitro::crypto { class HybridBlake3Spec; }
+
+#include <NitroModules/ArrayBuffer.hpp>
+#include <string>
+#include <optional>
+#include <memory>
+#include "HybridBlake3Spec.hpp"
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Blake3`
+   * Inherit this class to create instances of `HybridBlake3Spec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridBlake3: public HybridBlake3Spec {
+   * public:
+   *   HybridBlake3(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridBlake3Spec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridBlake3Spec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridBlake3Spec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual void initHash() = 0;
+      virtual void initKeyed(const std::shared_ptr<ArrayBuffer>& key) = 0;
+      virtual void initDeriveKey(const std::string& context) = 0;
+      virtual void update(const std::shared_ptr<ArrayBuffer>& data) = 0;
+      virtual std::shared_ptr<ArrayBuffer> digest(std::optional<double> length) = 0;
+      virtual void reset() = 0;
+      virtual std::shared_ptr<HybridBlake3Spec> copy() = 0;
+      virtual std::string getVersion() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Blake3";
+  };
+
+} // namespace margelo::nitro::crypto

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

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

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

@@ -0,0 +1,67 @@
+///
+/// HybridCipherFactorySpec.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 `HybridCipherSpec` to properly resolve imports.
+namespace margelo::nitro::crypto { class HybridCipherSpec; }
+// Forward declaration of `CipherArgs` to properly resolve imports.
+namespace margelo::nitro::crypto { struct CipherArgs; }
+
+#include <memory>
+#include "HybridCipherSpec.hpp"
+#include "CipherArgs.hpp"
+
+namespace margelo::nitro::crypto {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `CipherFactory`
+   * Inherit this class to create instances of `HybridCipherFactorySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCipherFactory: public HybridCipherFactorySpec {
+   * public:
+   *   HybridCipherFactory(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCipherFactorySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCipherFactorySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCipherFactorySpec() override = default;
+
+    public:
+      // Properties
+      
+
+    public:
+      // Methods
+      virtual std::shared_ptr<HybridCipherSpec> createCipher(const CipherArgs& args) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "CipherFactory";
+  };
+
+} // namespace margelo::nitro::crypto

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

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