@chilkat/react-native 11.6.1

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

@@ -0,0 +1,215 @@
+///
+/// HybridCrypt2Spec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridCrypt2Spec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridCrypt2Spec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridCrypt2Spec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridCrypt2Spec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridCrypt2Spec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridCrypt2Spec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridCrypt2Spec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridCrypt2Spec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridCrypt2Spec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridCrypt2Spec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridCrypt2Spec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridCrypt2Spec::setLastMethodSuccess);
+      prototype.registerHybridGetter("abortCurrent", &HybridCrypt2Spec::getAbortCurrent);
+      prototype.registerHybridSetter("abortCurrent", &HybridCrypt2Spec::setAbortCurrent);
+      prototype.registerHybridGetter("blockSize", &HybridCrypt2Spec::getBlockSize);
+      prototype.registerHybridGetter("cadesEnabled", &HybridCrypt2Spec::getCadesEnabled);
+      prototype.registerHybridSetter("cadesEnabled", &HybridCrypt2Spec::setCadesEnabled);
+      prototype.registerHybridGetter("cadesSigPolicyHash", &HybridCrypt2Spec::getCadesSigPolicyHash);
+      prototype.registerHybridSetter("cadesSigPolicyHash", &HybridCrypt2Spec::setCadesSigPolicyHash);
+      prototype.registerHybridGetter("cadesSigPolicyId", &HybridCrypt2Spec::getCadesSigPolicyId);
+      prototype.registerHybridSetter("cadesSigPolicyId", &HybridCrypt2Spec::setCadesSigPolicyId);
+      prototype.registerHybridGetter("cadesSigPolicyUri", &HybridCrypt2Spec::getCadesSigPolicyUri);
+      prototype.registerHybridSetter("cadesSigPolicyUri", &HybridCrypt2Spec::setCadesSigPolicyUri);
+      prototype.registerHybridGetter("charset", &HybridCrypt2Spec::getCharset);
+      prototype.registerHybridSetter("charset", &HybridCrypt2Spec::setCharset);
+      prototype.registerHybridGetter("cipherMode", &HybridCrypt2Spec::getCipherMode);
+      prototype.registerHybridSetter("cipherMode", &HybridCrypt2Spec::setCipherMode);
+      prototype.registerHybridGetter("cryptAlgorithm", &HybridCrypt2Spec::getCryptAlgorithm);
+      prototype.registerHybridSetter("cryptAlgorithm", &HybridCrypt2Spec::setCryptAlgorithm);
+      prototype.registerHybridGetter("encodingMode", &HybridCrypt2Spec::getEncodingMode);
+      prototype.registerHybridSetter("encodingMode", &HybridCrypt2Spec::setEncodingMode);
+      prototype.registerHybridGetter("firstChunk", &HybridCrypt2Spec::getFirstChunk);
+      prototype.registerHybridSetter("firstChunk", &HybridCrypt2Spec::setFirstChunk);
+      prototype.registerHybridGetter("hashAlgorithm", &HybridCrypt2Spec::getHashAlgorithm);
+      prototype.registerHybridSetter("hashAlgorithm", &HybridCrypt2Spec::setHashAlgorithm);
+      prototype.registerHybridGetter("havalRounds", &HybridCrypt2Spec::getHavalRounds);
+      prototype.registerHybridSetter("havalRounds", &HybridCrypt2Spec::setHavalRounds);
+      prototype.registerHybridGetter("heartbeatMs", &HybridCrypt2Spec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridCrypt2Spec::setHeartbeatMs);
+      prototype.registerHybridGetter("includeCertChain", &HybridCrypt2Spec::getIncludeCertChain);
+      prototype.registerHybridSetter("includeCertChain", &HybridCrypt2Spec::setIncludeCertChain);
+      prototype.registerHybridGetter("initialCount", &HybridCrypt2Spec::getInitialCount);
+      prototype.registerHybridSetter("initialCount", &HybridCrypt2Spec::setInitialCount);
+      prototype.registerHybridGetter("iterationCount", &HybridCrypt2Spec::getIterationCount);
+      prototype.registerHybridSetter("iterationCount", &HybridCrypt2Spec::setIterationCount);
+      prototype.registerHybridGetter("keyLength", &HybridCrypt2Spec::getKeyLength);
+      prototype.registerHybridSetter("keyLength", &HybridCrypt2Spec::setKeyLength);
+      prototype.registerHybridGetter("lastChunk", &HybridCrypt2Spec::getLastChunk);
+      prototype.registerHybridSetter("lastChunk", &HybridCrypt2Spec::setLastChunk);
+      prototype.registerHybridGetter("macAlgorithm", &HybridCrypt2Spec::getMacAlgorithm);
+      prototype.registerHybridSetter("macAlgorithm", &HybridCrypt2Spec::setMacAlgorithm);
+      prototype.registerHybridGetter("numSignerCerts", &HybridCrypt2Spec::getNumSignerCerts);
+      prototype.registerHybridGetter("paddingScheme", &HybridCrypt2Spec::getPaddingScheme);
+      prototype.registerHybridSetter("paddingScheme", &HybridCrypt2Spec::setPaddingScheme);
+      prototype.registerHybridGetter("pbesAlgorithm", &HybridCrypt2Spec::getPbesAlgorithm);
+      prototype.registerHybridSetter("pbesAlgorithm", &HybridCrypt2Spec::setPbesAlgorithm);
+      prototype.registerHybridGetter("pbesPassword", &HybridCrypt2Spec::getPbesPassword);
+      prototype.registerHybridSetter("pbesPassword", &HybridCrypt2Spec::setPbesPassword);
+      prototype.registerHybridGetter("pkcs7CryptAlg", &HybridCrypt2Spec::getPkcs7CryptAlg);
+      prototype.registerHybridSetter("pkcs7CryptAlg", &HybridCrypt2Spec::setPkcs7CryptAlg);
+      prototype.registerHybridGetter("rc2EffectiveKeyLength", &HybridCrypt2Spec::getRc2EffectiveKeyLength);
+      prototype.registerHybridSetter("rc2EffectiveKeyLength", &HybridCrypt2Spec::setRc2EffectiveKeyLength);
+      prototype.registerHybridGetter("uuFilename", &HybridCrypt2Spec::getUuFilename);
+      prototype.registerHybridSetter("uuFilename", &HybridCrypt2Spec::setUuFilename);
+      prototype.registerHybridGetter("uuMode", &HybridCrypt2Spec::getUuMode);
+      prototype.registerHybridSetter("uuMode", &HybridCrypt2Spec::setUuMode);
+      prototype.registerHybridGetter("bCryptWorkFactor", &HybridCrypt2Spec::getBCryptWorkFactor);
+      prototype.registerHybridSetter("bCryptWorkFactor", &HybridCrypt2Spec::setBCryptWorkFactor);
+      prototype.registerHybridGetter("signingAlg", &HybridCrypt2Spec::getSigningAlg);
+      prototype.registerHybridSetter("signingAlg", &HybridCrypt2Spec::setSigningAlg);
+      prototype.registerHybridGetter("oaepHash", &HybridCrypt2Spec::getOaepHash);
+      prototype.registerHybridSetter("oaepHash", &HybridCrypt2Spec::setOaepHash);
+      prototype.registerHybridGetter("oaepPadding", &HybridCrypt2Spec::getOaepPadding);
+      prototype.registerHybridSetter("oaepPadding", &HybridCrypt2Spec::setOaepPadding);
+      prototype.registerHybridGetter("oaepMgfHash", &HybridCrypt2Spec::getOaepMgfHash);
+      prototype.registerHybridSetter("oaepMgfHash", &HybridCrypt2Spec::setOaepMgfHash);
+      prototype.registerHybridGetter("signingAttributes", &HybridCrypt2Spec::getSigningAttributes);
+      prototype.registerHybridSetter("signingAttributes", &HybridCrypt2Spec::setSigningAttributes);
+      prototype.registerHybridGetter("cmsOptions", &HybridCrypt2Spec::getCmsOptions);
+      prototype.registerHybridSetter("cmsOptions", &HybridCrypt2Spec::setCmsOptions);
+      prototype.registerHybridGetter("uncommonOptions", &HybridCrypt2Spec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridCrypt2Spec::setUncommonOptions);
+      prototype.registerHybridGetter("onPercentDone", &HybridCrypt2Spec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridCrypt2Spec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridCrypt2Spec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridCrypt2Spec::setOnProgressInfo);
+      prototype.registerHybridMethod("addEncryptCert", &HybridCrypt2Spec::addEncryptCert);
+      prototype.registerHybridMethod("addPfxSourceFile", &HybridCrypt2Spec::addPfxSourceFile);
+      prototype.registerHybridMethod("ckDecryptFile", &HybridCrypt2Spec::ckDecryptFile);
+      prototype.registerHybridMethod("ckDecryptFileAsync", &HybridCrypt2Spec::ckDecryptFileAsync);
+      prototype.registerHybridMethod("ckEncryptFile", &HybridCrypt2Spec::ckEncryptFile);
+      prototype.registerHybridMethod("ckEncryptFileAsync", &HybridCrypt2Spec::ckEncryptFileAsync);
+      prototype.registerHybridMethod("clearEncryptCerts", &HybridCrypt2Spec::clearEncryptCerts);
+      prototype.registerHybridMethod("crcFile", &HybridCrypt2Spec::crcFile);
+      prototype.registerHybridMethod("crcFileAsync", &HybridCrypt2Spec::crcFileAsync);
+      prototype.registerHybridMethod("createP7M", &HybridCrypt2Spec::createP7M);
+      prototype.registerHybridMethod("createP7MAsync", &HybridCrypt2Spec::createP7MAsync);
+      prototype.registerHybridMethod("createP7S", &HybridCrypt2Spec::createP7S);
+      prototype.registerHybridMethod("createP7SAsync", &HybridCrypt2Spec::createP7SAsync);
+      prototype.registerHybridMethod("decodeString", &HybridCrypt2Spec::decodeString);
+      prototype.registerHybridMethod("decryptEncoded", &HybridCrypt2Spec::decryptEncoded);
+      prototype.registerHybridMethod("decryptStringENC", &HybridCrypt2Spec::decryptStringENC);
+      prototype.registerHybridMethod("encodeBytes", &HybridCrypt2Spec::encodeBytes);
+      prototype.registerHybridMethod("encodeString", &HybridCrypt2Spec::encodeString);
+      prototype.registerHybridMethod("encryptEncoded", &HybridCrypt2Spec::encryptEncoded);
+      prototype.registerHybridMethod("encryptStringENC", &HybridCrypt2Spec::encryptStringENC);
+      prototype.registerHybridMethod("genRandomBytesENC", &HybridCrypt2Spec::genRandomBytesENC);
+      prototype.registerHybridMethod("generateUuid", &HybridCrypt2Spec::generateUuid);
+      prototype.registerHybridMethod("getEncodedAuthTag", &HybridCrypt2Spec::getEncodedAuthTag);
+      prototype.registerHybridMethod("getEncodedIV", &HybridCrypt2Spec::getEncodedIV);
+      prototype.registerHybridMethod("getSignatureSigningTimeStr", &HybridCrypt2Spec::getSignatureSigningTimeStr);
+      prototype.registerHybridMethod("hasSignatureSigningTime", &HybridCrypt2Spec::hasSignatureSigningTime);
+      prototype.registerHybridMethod("hashBeginString", &HybridCrypt2Spec::hashBeginString);
+      prototype.registerHybridMethod("hashFileENC", &HybridCrypt2Spec::hashFileENC);
+      prototype.registerHybridMethod("hashFileENCAsync", &HybridCrypt2Spec::hashFileENCAsync);
+      prototype.registerHybridMethod("hashFinalENC", &HybridCrypt2Spec::hashFinalENC);
+      prototype.registerHybridMethod("hashMoreString", &HybridCrypt2Spec::hashMoreString);
+      prototype.registerHybridMethod("hashStringENC", &HybridCrypt2Spec::hashStringENC);
+      prototype.registerHybridMethod("macStringENC", &HybridCrypt2Spec::macStringENC);
+      prototype.registerHybridMethod("mySqlAesDecrypt", &HybridCrypt2Spec::mySqlAesDecrypt);
+      prototype.registerHybridMethod("mySqlAesEncrypt", &HybridCrypt2Spec::mySqlAesEncrypt);
+      prototype.registerHybridMethod("opaqueSignStringENC", &HybridCrypt2Spec::opaqueSignStringENC);
+      prototype.registerHybridMethod("opaqueSignStringENCAsync", &HybridCrypt2Spec::opaqueSignStringENCAsync);
+      prototype.registerHybridMethod("opaqueVerifyStringENC", &HybridCrypt2Spec::opaqueVerifyStringENC);
+      prototype.registerHybridMethod("pbkdf1", &HybridCrypt2Spec::pbkdf1);
+      prototype.registerHybridMethod("pbkdf2", &HybridCrypt2Spec::pbkdf2);
+      prototype.registerHybridMethod("randomizeIV", &HybridCrypt2Spec::randomizeIV);
+      prototype.registerHybridMethod("reEncode", &HybridCrypt2Spec::reEncode);
+      prototype.registerHybridMethod("setDecryptCert", &HybridCrypt2Spec::setDecryptCert);
+      prototype.registerHybridMethod("setDecryptCert2", &HybridCrypt2Spec::setDecryptCert2);
+      prototype.registerHybridMethod("setEncodedAad", &HybridCrypt2Spec::setEncodedAad);
+      prototype.registerHybridMethod("setEncodedAuthTag", &HybridCrypt2Spec::setEncodedAuthTag);
+      prototype.registerHybridMethod("setEncodedIV", &HybridCrypt2Spec::setEncodedIV);
+      prototype.registerHybridMethod("setEncodedKey", &HybridCrypt2Spec::setEncodedKey);
+      prototype.registerHybridMethod("setEncodedSalt", &HybridCrypt2Spec::setEncodedSalt);
+      prototype.registerHybridMethod("setEncryptCert", &HybridCrypt2Spec::setEncryptCert);
+      prototype.registerHybridMethod("setIV", &HybridCrypt2Spec::setIV);
+      prototype.registerHybridMethod("setMacKeyEncoded", &HybridCrypt2Spec::setMacKeyEncoded);
+      prototype.registerHybridMethod("setMacKeyString", &HybridCrypt2Spec::setMacKeyString);
+      prototype.registerHybridMethod("setSecretKey", &HybridCrypt2Spec::setSecretKey);
+      prototype.registerHybridMethod("setSigningCert", &HybridCrypt2Spec::setSigningCert);
+      prototype.registerHybridMethod("setSigningCert2", &HybridCrypt2Spec::setSigningCert2);
+      prototype.registerHybridMethod("setVerifyCert", &HybridCrypt2Spec::setVerifyCert);
+      prototype.registerHybridMethod("signStringENC", &HybridCrypt2Spec::signStringENC);
+      prototype.registerHybridMethod("signStringENCAsync", &HybridCrypt2Spec::signStringENCAsync);
+      prototype.registerHybridMethod("useCertVault", &HybridCrypt2Spec::useCertVault);
+      prototype.registerHybridMethod("verifyP7M", &HybridCrypt2Spec::verifyP7M);
+      prototype.registerHybridMethod("verifyP7S", &HybridCrypt2Spec::verifyP7S);
+      prototype.registerHybridMethod("verifyStringENC", &HybridCrypt2Spec::verifyStringENC);
+      prototype.registerHybridMethod("bCryptHash", &HybridCrypt2Spec::bCryptHash);
+      prototype.registerHybridMethod("bCryptVerify", &HybridCrypt2Spec::bCryptVerify);
+      prototype.registerHybridMethod("aesKeyWrap", &HybridCrypt2Spec::aesKeyWrap);
+      prototype.registerHybridMethod("aesKeyUnwrap", &HybridCrypt2Spec::aesKeyUnwrap);
+      prototype.registerHybridMethod("hashBdENC", &HybridCrypt2Spec::hashBdENC);
+      prototype.registerHybridMethod("macBdENC", &HybridCrypt2Spec::macBdENC);
+      prototype.registerHybridMethod("encryptBd", &HybridCrypt2Spec::encryptBd);
+      prototype.registerHybridMethod("decryptBd", &HybridCrypt2Spec::decryptBd);
+      prototype.registerHybridMethod("encryptSb", &HybridCrypt2Spec::encryptSb);
+      prototype.registerHybridMethod("decryptSb", &HybridCrypt2Spec::decryptSb);
+      prototype.registerHybridMethod("signBdENC", &HybridCrypt2Spec::signBdENC);
+      prototype.registerHybridMethod("signBdENCAsync", &HybridCrypt2Spec::signBdENCAsync);
+      prototype.registerHybridMethod("signSbENC", &HybridCrypt2Spec::signSbENC);
+      prototype.registerHybridMethod("signSbENCAsync", &HybridCrypt2Spec::signSbENCAsync);
+      prototype.registerHybridMethod("opaqueSignBd", &HybridCrypt2Spec::opaqueSignBd);
+      prototype.registerHybridMethod("opaqueSignBdAsync", &HybridCrypt2Spec::opaqueSignBdAsync);
+      prototype.registerHybridMethod("opaqueVerifyBd", &HybridCrypt2Spec::opaqueVerifyBd);
+      prototype.registerHybridMethod("verifyBdENC", &HybridCrypt2Spec::verifyBdENC);
+      prototype.registerHybridMethod("verifySbENC", &HybridCrypt2Spec::verifySbENC);
+      prototype.registerHybridMethod("encryptSecureENC", &HybridCrypt2Spec::encryptSecureENC);
+      prototype.registerHybridMethod("decryptSecureENC", &HybridCrypt2Spec::decryptSecureENC);
+      prototype.registerHybridMethod("getSignedAttributes", &HybridCrypt2Spec::getSignedAttributes);
+      prototype.registerHybridMethod("hotp", &HybridCrypt2Spec::hotp);
+      prototype.registerHybridMethod("encodeInt", &HybridCrypt2Spec::encodeInt);
+      prototype.registerHybridMethod("totp", &HybridCrypt2Spec::totp);
+      prototype.registerHybridMethod("setTsaHttpObj", &HybridCrypt2Spec::setTsaHttpObj);
+      prototype.registerHybridMethod("hashBeginBytes2", &HybridCrypt2Spec::hashBeginBytes2);
+      prototype.registerHybridMethod("hashMoreBytes2", &HybridCrypt2Spec::hashMoreBytes2);
+      prototype.registerHybridMethod("addSigningCert", &HybridCrypt2Spec::addSigningCert);
+      prototype.registerHybridMethod("clearSigningCerts", &HybridCrypt2Spec::clearSigningCerts);
+      prototype.registerHybridMethod("coSign", &HybridCrypt2Spec::coSign);
+      prototype.registerHybridMethod("signHashENC", &HybridCrypt2Spec::signHashENC);
+      prototype.registerHybridMethod("signHashENCAsync", &HybridCrypt2Spec::signHashENCAsync);
+      prototype.registerHybridMethod("xtsSetEncodedTweakValue", &HybridCrypt2Spec::xtsSetEncodedTweakValue);
+      prototype.registerHybridMethod("xtsSetDataUnitNumber", &HybridCrypt2Spec::xtsSetDataUnitNumber);
+      prototype.registerHybridMethod("xtsSetEncodedTweakKey", &HybridCrypt2Spec::xtsSetEncodedTweakKey);
+      prototype.registerHybridMethod("aesKeyWrapWithPadding", &HybridCrypt2Spec::aesKeyWrapWithPadding);
+      prototype.registerHybridMethod("aesKeyUnwrapWithPadding", &HybridCrypt2Spec::aesKeyUnwrapWithPadding);
+      prototype.registerHybridMethod("getLastJsonData", &HybridCrypt2Spec::getLastJsonData);
+      prototype.registerHybridMethod("lastDecryptCert", &HybridCrypt2Spec::lastDecryptCert);
+      prototype.registerHybridMethod("lastSignerCert", &HybridCrypt2Spec::lastSignerCert);
+      prototype.registerHybridMethod("addPfxSourceBd", &HybridCrypt2Spec::addPfxSourceBd);
+      prototype.registerHybridMethod("crcBd", &HybridCrypt2Spec::crcBd);
+      prototype.registerHybridMethod("hashChunkBd", &HybridCrypt2Spec::hashChunkBd);
+      prototype.registerHybridMethod("argon2DeriveKey", &HybridCrypt2Spec::argon2DeriveKey);
+      prototype.registerHybridMethod("argon2HashPassword", &HybridCrypt2Spec::argon2HashPassword);
+      prototype.registerHybridMethod("argon2VerifyPassword", &HybridCrypt2Spec::argon2VerifyPassword);
+      prototype.registerHybridMethod("abort", &HybridCrypt2Spec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,283 @@
+///
+/// HybridCrypt2Spec.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 `HybridCertSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCertSpec; }
+// Forward declaration of `HybridPrivateKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPrivateKeySpec; }
+// Forward declaration of `HybridXmlCertVaultSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridXmlCertVaultSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+// Forward declaration of `HybridSecureStringSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSecureStringSpec; }
+// Forward declaration of `HybridHttpSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridHttpSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridCertSpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include <NitroModules/ArrayBuffer.hpp>
+#include "HybridPrivateKeySpec.hpp"
+#include "HybridXmlCertVaultSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridSecureStringSpec.hpp"
+#include "HybridHttpSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Crypt2`
+   * Inherit this class to create instances of `HybridCrypt2Spec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCrypt2: public HybridCrypt2Spec {
+   * public:
+   *   HybridCrypt2(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCrypt2Spec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCrypt2Spec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCrypt2Spec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual bool getAbortCurrent() = 0;
+      virtual void setAbortCurrent(bool abortCurrent) = 0;
+      virtual double getBlockSize() = 0;
+      virtual bool getCadesEnabled() = 0;
+      virtual void setCadesEnabled(bool cadesEnabled) = 0;
+      virtual std::string getCadesSigPolicyHash() = 0;
+      virtual void setCadesSigPolicyHash(const std::string& cadesSigPolicyHash) = 0;
+      virtual std::string getCadesSigPolicyId() = 0;
+      virtual void setCadesSigPolicyId(const std::string& cadesSigPolicyId) = 0;
+      virtual std::string getCadesSigPolicyUri() = 0;
+      virtual void setCadesSigPolicyUri(const std::string& cadesSigPolicyUri) = 0;
+      virtual std::string getCharset() = 0;
+      virtual void setCharset(const std::string& charset) = 0;
+      virtual std::string getCipherMode() = 0;
+      virtual void setCipherMode(const std::string& cipherMode) = 0;
+      virtual std::string getCryptAlgorithm() = 0;
+      virtual void setCryptAlgorithm(const std::string& cryptAlgorithm) = 0;
+      virtual std::string getEncodingMode() = 0;
+      virtual void setEncodingMode(const std::string& encodingMode) = 0;
+      virtual bool getFirstChunk() = 0;
+      virtual void setFirstChunk(bool firstChunk) = 0;
+      virtual std::string getHashAlgorithm() = 0;
+      virtual void setHashAlgorithm(const std::string& hashAlgorithm) = 0;
+      virtual double getHavalRounds() = 0;
+      virtual void setHavalRounds(double havalRounds) = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual bool getIncludeCertChain() = 0;
+      virtual void setIncludeCertChain(bool includeCertChain) = 0;
+      virtual double getInitialCount() = 0;
+      virtual void setInitialCount(double initialCount) = 0;
+      virtual double getIterationCount() = 0;
+      virtual void setIterationCount(double iterationCount) = 0;
+      virtual double getKeyLength() = 0;
+      virtual void setKeyLength(double keyLength) = 0;
+      virtual bool getLastChunk() = 0;
+      virtual void setLastChunk(bool lastChunk) = 0;
+      virtual std::string getMacAlgorithm() = 0;
+      virtual void setMacAlgorithm(const std::string& macAlgorithm) = 0;
+      virtual double getNumSignerCerts() = 0;
+      virtual double getPaddingScheme() = 0;
+      virtual void setPaddingScheme(double paddingScheme) = 0;
+      virtual std::string getPbesAlgorithm() = 0;
+      virtual void setPbesAlgorithm(const std::string& pbesAlgorithm) = 0;
+      virtual std::string getPbesPassword() = 0;
+      virtual void setPbesPassword(const std::string& pbesPassword) = 0;
+      virtual std::string getPkcs7CryptAlg() = 0;
+      virtual void setPkcs7CryptAlg(const std::string& pkcs7CryptAlg) = 0;
+      virtual double getRc2EffectiveKeyLength() = 0;
+      virtual void setRc2EffectiveKeyLength(double rc2EffectiveKeyLength) = 0;
+      virtual std::string getUuFilename() = 0;
+      virtual void setUuFilename(const std::string& uuFilename) = 0;
+      virtual std::string getUuMode() = 0;
+      virtual void setUuMode(const std::string& uuMode) = 0;
+      virtual double getBCryptWorkFactor() = 0;
+      virtual void setBCryptWorkFactor(double bCryptWorkFactor) = 0;
+      virtual std::string getSigningAlg() = 0;
+      virtual void setSigningAlg(const std::string& signingAlg) = 0;
+      virtual std::string getOaepHash() = 0;
+      virtual void setOaepHash(const std::string& oaepHash) = 0;
+      virtual bool getOaepPadding() = 0;
+      virtual void setOaepPadding(bool oaepPadding) = 0;
+      virtual std::string getOaepMgfHash() = 0;
+      virtual void setOaepMgfHash(const std::string& oaepMgfHash) = 0;
+      virtual std::string getSigningAttributes() = 0;
+      virtual void setSigningAttributes(const std::string& signingAttributes) = 0;
+      virtual std::string getCmsOptions() = 0;
+      virtual void setCmsOptions(const std::string& cmsOptions) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual std::optional<std::function<void(double /* pctDone */)>> getOnPercentDone() = 0;
+      virtual void setOnPercentDone(const std::optional<std::function<void(double /* pctDone */)>>& onPercentDone) = 0;
+      virtual std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>> getOnProgressInfo() = 0;
+      virtual void setOnProgressInfo(const std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>>& onProgressInfo) = 0;
+
+    public:
+      // Methods
+      virtual void addEncryptCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void addPfxSourceFile(const std::string& pfxFilePath, const std::string& pfxPassword) = 0;
+      virtual void ckDecryptFile(const std::string& srcFile, const std::string& destFile) = 0;
+      virtual std::shared_ptr<Promise<void>> ckDecryptFileAsync(const std::string& srcFile, const std::string& destFile) = 0;
+      virtual void ckEncryptFile(const std::string& srcFile, const std::string& destFile) = 0;
+      virtual std::shared_ptr<Promise<void>> ckEncryptFileAsync(const std::string& srcFile, const std::string& destFile) = 0;
+      virtual void clearEncryptCerts() = 0;
+      virtual double crcFile(const std::string& crcAlg, const std::string& path) = 0;
+      virtual std::shared_ptr<Promise<double>> crcFileAsync(const std::string& crcAlg, const std::string& path) = 0;
+      virtual void createP7M(const std::string& inFilename, const std::string& p7mPath) = 0;
+      virtual std::shared_ptr<Promise<void>> createP7MAsync(const std::string& inFilename, const std::string& p7mPath) = 0;
+      virtual void createP7S(const std::string& inFilename, const std::string& p7sPath) = 0;
+      virtual std::shared_ptr<Promise<void>> createP7SAsync(const std::string& inFilename, const std::string& p7sPath) = 0;
+      virtual std::string decodeString(const std::string& inStr, const std::string& charset, const std::string& encoding) = 0;
+      virtual std::string decryptEncoded(const std::string& encodedEncryptedData) = 0;
+      virtual std::string decryptStringENC(const std::string& str) = 0;
+      virtual std::string encodeBytes(const std::shared_ptr<ArrayBuffer>& byteData, const std::string& encoding) = 0;
+      virtual std::string encodeString(const std::string& strToEncode, const std::string& charsetName, const std::string& toEncodingName) = 0;
+      virtual std::string encryptEncoded(const std::string& str) = 0;
+      virtual std::string encryptStringENC(const std::string& str) = 0;
+      virtual std::string genRandomBytesENC(double numBytes) = 0;
+      virtual std::string generateUuid() = 0;
+      virtual std::string getEncodedAuthTag(const std::string& encoding) = 0;
+      virtual std::string getEncodedIV(const std::string& encoding) = 0;
+      virtual std::string getSignatureSigningTimeStr(double index) = 0;
+      virtual bool hasSignatureSigningTime(double index) = 0;
+      virtual void hashBeginString(const std::string& strData) = 0;
+      virtual std::string hashFileENC(const std::string& path) = 0;
+      virtual std::shared_ptr<Promise<std::string>> hashFileENCAsync(const std::string& path) = 0;
+      virtual std::string hashFinalENC() = 0;
+      virtual void hashMoreString(const std::string& strData) = 0;
+      virtual std::string hashStringENC(const std::string& str) = 0;
+      virtual std::string macStringENC(const std::string& inText) = 0;
+      virtual std::string mySqlAesDecrypt(const std::string& strEncryptedHex, const std::string& strPassword) = 0;
+      virtual std::string mySqlAesEncrypt(const std::string& strData, const std::string& strPassword) = 0;
+      virtual std::string opaqueSignStringENC(const std::string& str) = 0;
+      virtual std::shared_ptr<Promise<std::string>> opaqueSignStringENCAsync(const std::string& str) = 0;
+      virtual std::string opaqueVerifyStringENC(const std::string& p7m) = 0;
+      virtual std::string pbkdf1(const std::string& password, const std::string& charset, const std::string& hashAlg, const std::string& salt, double iterationCount, double outputKeyBitLen, const std::string& encoding) = 0;
+      virtual std::string pbkdf2(const std::string& password, const std::string& charset, const std::string& hashAlg, const std::string& salt, double iterationCount, double outputKeyBitLen, const std::string& encoding) = 0;
+      virtual void randomizeIV() = 0;
+      virtual std::string reEncode(const std::string& encodedData, const std::string& fromEncoding, const std::string& toEncoding) = 0;
+      virtual void setDecryptCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void setDecryptCert2(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& key) = 0;
+      virtual void setEncodedAad(const std::string& aadStr, const std::string& encoding) = 0;
+      virtual void setEncodedAuthTag(const std::string& authTagStr, const std::string& encoding) = 0;
+      virtual void setEncodedIV(const std::string& ivStr, const std::string& encoding) = 0;
+      virtual void setEncodedKey(const std::string& keyStr, const std::string& encoding) = 0;
+      virtual void setEncodedSalt(const std::string& saltStr, const std::string& encoding) = 0;
+      virtual void setEncryptCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void setIV(const std::shared_ptr<ArrayBuffer>& byteData) = 0;
+      virtual void setMacKeyEncoded(const std::string& key, const std::string& encoding) = 0;
+      virtual void setMacKeyString(const std::string& key) = 0;
+      virtual void setSecretKey(const std::shared_ptr<ArrayBuffer>& byteData) = 0;
+      virtual void setSigningCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void setSigningCert2(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) = 0;
+      virtual void setVerifyCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual std::string signStringENC(const std::string& str) = 0;
+      virtual std::shared_ptr<Promise<std::string>> signStringENCAsync(const std::string& str) = 0;
+      virtual void useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) = 0;
+      virtual void verifyP7M(const std::string& p7mPath, const std::string& destPath) = 0;
+      virtual void verifyP7S(const std::string& originalDataPath, const std::string& p7sPath) = 0;
+      virtual void verifyStringENC(const std::string& str, const std::string& encodedSig) = 0;
+      virtual std::string bCryptHash(const std::string& password) = 0;
+      virtual void bCryptVerify(const std::string& password, const std::string& bcryptHash) = 0;
+      virtual std::string aesKeyWrap(const std::string& kek, const std::string& keyData, const std::string& encoding) = 0;
+      virtual std::string aesKeyUnwrap(const std::string& kek, const std::string& wrappedKeyData, const std::string& encoding) = 0;
+      virtual std::string hashBdENC(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual std::string macBdENC(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void encryptBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void decryptBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void encryptSb(const std::shared_ptr<HybridStringBuilderSpec>& sbIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) = 0;
+      virtual void decryptSb(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridStringBuilderSpec>& sbOut) = 0;
+      virtual std::string signBdENC(const std::shared_ptr<HybridBinDataSpec>& dataToSign) = 0;
+      virtual std::shared_ptr<Promise<std::string>> signBdENCAsync(const std::shared_ptr<HybridBinDataSpec>& dataToSign) = 0;
+      virtual std::string signSbENC(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual std::shared_ptr<Promise<std::string>> signSbENCAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void opaqueSignBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual std::shared_ptr<Promise<void>> opaqueSignBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void opaqueVerifyBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void verifyBdENC(const std::shared_ptr<HybridBinDataSpec>& data, const std::string& encodedSig) = 0;
+      virtual void verifySbENC(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& encodedSig) = 0;
+      virtual std::string encryptSecureENC(const std::shared_ptr<HybridSecureStringSpec>& secureStr) = 0;
+      virtual void decryptSecureENC(const std::string& cipherText, const std::shared_ptr<HybridSecureStringSpec>& secureStr) = 0;
+      virtual bool getSignedAttributes(double signerIndex, const std::shared_ptr<HybridBinDataSpec>& pkcs7Der, const std::shared_ptr<HybridStringBuilderSpec>& sbJson) = 0;
+      virtual std::string hotp(const std::string& secret, const std::string& secretEnc, const std::string& counterHex, double numDigits, double truncOffset, const std::string& hashAlg) = 0;
+      virtual std::string encodeInt(double value, double numBytes, bool littleEndian, const std::string& encoding) = 0;
+      virtual std::string totp(const std::string& secret, const std::string& secretEnc, const std::string& t0, const std::string& tNow, double tStep, double numDigits, double truncOffset, const std::string& hashAlg) = 0;
+      virtual void setTsaHttpObj(const std::shared_ptr<HybridHttpSpec>& http) = 0;
+      virtual void hashBeginBytes2(const std::shared_ptr<ArrayBuffer>& byteData) = 0;
+      virtual void hashMoreBytes2(const std::shared_ptr<ArrayBuffer>& byteData) = 0;
+      virtual void addSigningCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void clearSigningCerts() = 0;
+      virtual void coSign(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridBinDataSpec>& bdOut) = 0;
+      virtual std::string signHashENC(const std::string& encodedHash, const std::string& hashAlg, const std::string& hashEncoding) = 0;
+      virtual std::shared_ptr<Promise<std::string>> signHashENCAsync(const std::string& encodedHash, const std::string& hashAlg, const std::string& hashEncoding) = 0;
+      virtual void xtsSetEncodedTweakValue(const std::string& tweak, const std::string& encoding) = 0;
+      virtual void xtsSetDataUnitNumber(double loUint32, double hiUint32) = 0;
+      virtual void xtsSetEncodedTweakKey(const std::string& key, const std::string& encoding) = 0;
+      virtual std::string aesKeyWrapWithPadding(const std::string& kek, const std::string& keyData, const std::string& encoding) = 0;
+      virtual std::string aesKeyUnwrapWithPadding(const std::string& kek, const std::string& wrappedKeyData, const std::string& encoding) = 0;
+      virtual void getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void lastDecryptCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void lastSignerCert(double index, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void addPfxSourceBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) = 0;
+      virtual double crcBd(const std::string& crcAlg, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void hashChunkBd(bool firstChunk, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void argon2DeriveKey(const std::string& password, const std::string& json, const std::shared_ptr<HybridBinDataSpec>& bdKey) = 0;
+      virtual std::string argon2HashPassword(const std::string& password, const std::string& json) = 0;
+      virtual double argon2VerifyPassword(const std::string& password, const std::string& json, const std::string& phcHash) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Crypt2";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,61 @@
+///
+/// HybridCsrSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridCsrSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridCsrSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridCsrSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridCsrSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridCsrSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridCsrSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridCsrSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridCsrSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridCsrSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridCsrSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridCsrSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridCsrSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("commonName", &HybridCsrSpec::getCommonName);
+      prototype.registerHybridSetter("commonName", &HybridCsrSpec::setCommonName);
+      prototype.registerHybridGetter("country", &HybridCsrSpec::getCountry);
+      prototype.registerHybridSetter("country", &HybridCsrSpec::setCountry);
+      prototype.registerHybridGetter("state", &HybridCsrSpec::getState);
+      prototype.registerHybridSetter("state", &HybridCsrSpec::setState);
+      prototype.registerHybridGetter("locality", &HybridCsrSpec::getLocality);
+      prototype.registerHybridSetter("locality", &HybridCsrSpec::setLocality);
+      prototype.registerHybridGetter("company", &HybridCsrSpec::getCompany);
+      prototype.registerHybridSetter("company", &HybridCsrSpec::setCompany);
+      prototype.registerHybridGetter("companyDivision", &HybridCsrSpec::getCompanyDivision);
+      prototype.registerHybridSetter("companyDivision", &HybridCsrSpec::setCompanyDivision);
+      prototype.registerHybridGetter("emailAddress", &HybridCsrSpec::getEmailAddress);
+      prototype.registerHybridSetter("emailAddress", &HybridCsrSpec::setEmailAddress);
+      prototype.registerHybridGetter("hashAlgorithm", &HybridCsrSpec::getHashAlgorithm);
+      prototype.registerHybridSetter("hashAlgorithm", &HybridCsrSpec::setHashAlgorithm);
+      prototype.registerHybridGetter("pssPadding", &HybridCsrSpec::getPssPadding);
+      prototype.registerHybridSetter("pssPadding", &HybridCsrSpec::setPssPadding);
+      prototype.registerHybridGetter("mgfHashAlg", &HybridCsrSpec::getMgfHashAlg);
+      prototype.registerHybridSetter("mgfHashAlg", &HybridCsrSpec::setMgfHashAlg);
+      prototype.registerHybridMethod("genCsrPem", &HybridCsrSpec::genCsrPem);
+      prototype.registerHybridMethod("genCsrBd", &HybridCsrSpec::genCsrBd);
+      prototype.registerHybridMethod("setSubjectField", &HybridCsrSpec::setSubjectField);
+      prototype.registerHybridMethod("loadCsrPem", &HybridCsrSpec::loadCsrPem);
+      prototype.registerHybridMethod("getSubjectField", &HybridCsrSpec::getSubjectField);
+      prototype.registerHybridMethod("getPublicKey", &HybridCsrSpec::getPublicKey);
+      prototype.registerHybridMethod("verifyCsr", &HybridCsrSpec::verifyCsr);
+      prototype.registerHybridMethod("addSan", &HybridCsrSpec::addSan);
+      prototype.registerHybridMethod("getSans", &HybridCsrSpec::getSans);
+      prototype.registerHybridMethod("setExtensionRequest", &HybridCsrSpec::setExtensionRequest);
+      prototype.registerHybridMethod("getExtensionRequest", &HybridCsrSpec::getExtensionRequest);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat