@chilkat/react-native 11.6.1

package/cpp/HybridCrypt2.cpp

@@ -0,0 +1,1517 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridCrypt2.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCert.hpp"
+#include "HybridHttp.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridPrivateKey.hpp"
+#include "HybridSecureString.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridXmlCertVault.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridCrypt2::HybridCrypt2()
+    : HybridObject(HybridCrypt2Spec::TAG), ChilkatObject<CkCrypt2>("Crypt2", CkCrypt2::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridCrypt2::HybridCrypt2(CkCrypt2* owned)
+    : HybridObject(HybridCrypt2Spec::TAG), ChilkatObject<CkCrypt2>("Crypt2", owned) {
+  init();
+}
+
+void HybridCrypt2::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridCrypt2::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridCrypt2::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCrypt2::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCrypt2::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCrypt2::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCrypt2::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridCrypt2::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridCrypt2::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridCrypt2::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridCrypt2::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridCrypt2::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridCrypt2::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+double HybridCrypt2::getBlockSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_BlockSize());
+}
+bool HybridCrypt2::getCadesEnabled() {
+  this->beginCall();
+  return this->ck().get_CadesEnabled();
+}
+void HybridCrypt2::setCadesEnabled(bool value) {
+  this->beginCall();
+  this->ck().put_CadesEnabled(value);
+}
+std::string HybridCrypt2::getCadesSigPolicyHash() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CadesSigPolicyHash(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setCadesSigPolicyHash(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "cadesSigPolicyHash");
+  this->ck().put_CadesSigPolicyHash(value.c_str());
+}
+std::string HybridCrypt2::getCadesSigPolicyId() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CadesSigPolicyId(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setCadesSigPolicyId(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "cadesSigPolicyId");
+  this->ck().put_CadesSigPolicyId(value.c_str());
+}
+std::string HybridCrypt2::getCadesSigPolicyUri() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CadesSigPolicyUri(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setCadesSigPolicyUri(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "cadesSigPolicyUri");
+  this->ck().put_CadesSigPolicyUri(value.c_str());
+}
+std::string HybridCrypt2::getCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Charset(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "charset");
+  this->ck().put_Charset(value.c_str());
+}
+std::string HybridCrypt2::getCipherMode() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CipherMode(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setCipherMode(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "cipherMode");
+  this->ck().put_CipherMode(value.c_str());
+}
+std::string HybridCrypt2::getCryptAlgorithm() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CryptAlgorithm(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setCryptAlgorithm(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "cryptAlgorithm");
+  this->ck().put_CryptAlgorithm(value.c_str());
+}
+std::string HybridCrypt2::getEncodingMode() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_EncodingMode(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setEncodingMode(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "encodingMode");
+  this->ck().put_EncodingMode(value.c_str());
+}
+bool HybridCrypt2::getFirstChunk() {
+  this->beginCall();
+  return this->ck().get_FirstChunk();
+}
+void HybridCrypt2::setFirstChunk(bool value) {
+  this->beginCall();
+  this->ck().put_FirstChunk(value);
+}
+std::string HybridCrypt2::getHashAlgorithm() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HashAlgorithm(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setHashAlgorithm(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "hashAlgorithm");
+  this->ck().put_HashAlgorithm(value.c_str());
+}
+double HybridCrypt2::getHavalRounds() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HavalRounds());
+}
+void HybridCrypt2::setHavalRounds(double value) {
+  this->beginCall();
+  this->ck().put_HavalRounds(rt::toInt(value, "havalRounds"));
+}
+double HybridCrypt2::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridCrypt2::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+bool HybridCrypt2::getIncludeCertChain() {
+  this->beginCall();
+  return this->ck().get_IncludeCertChain();
+}
+void HybridCrypt2::setIncludeCertChain(bool value) {
+  this->beginCall();
+  this->ck().put_IncludeCertChain(value);
+}
+double HybridCrypt2::getInitialCount() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_InitialCount());
+}
+void HybridCrypt2::setInitialCount(double value) {
+  this->beginCall();
+  this->ck().put_InitialCount(rt::toInt(value, "initialCount"));
+}
+double HybridCrypt2::getIterationCount() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_IterationCount());
+}
+void HybridCrypt2::setIterationCount(double value) {
+  this->beginCall();
+  this->ck().put_IterationCount(rt::toInt(value, "iterationCount"));
+}
+double HybridCrypt2::getKeyLength() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_KeyLength());
+}
+void HybridCrypt2::setKeyLength(double value) {
+  this->beginCall();
+  this->ck().put_KeyLength(rt::toInt(value, "keyLength"));
+}
+bool HybridCrypt2::getLastChunk() {
+  this->beginCall();
+  return this->ck().get_LastChunk();
+}
+void HybridCrypt2::setLastChunk(bool value) {
+  this->beginCall();
+  this->ck().put_LastChunk(value);
+}
+std::string HybridCrypt2::getMacAlgorithm() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_MacAlgorithm(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setMacAlgorithm(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "macAlgorithm");
+  this->ck().put_MacAlgorithm(value.c_str());
+}
+double HybridCrypt2::getNumSignerCerts() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumSignerCerts());
+}
+double HybridCrypt2::getPaddingScheme() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_PaddingScheme());
+}
+void HybridCrypt2::setPaddingScheme(double value) {
+  this->beginCall();
+  this->ck().put_PaddingScheme(rt::toInt(value, "paddingScheme"));
+}
+std::string HybridCrypt2::getPbesAlgorithm() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_PbesAlgorithm(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setPbesAlgorithm(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "pbesAlgorithm");
+  this->ck().put_PbesAlgorithm(value.c_str());
+}
+std::string HybridCrypt2::getPbesPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_PbesPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setPbesPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "pbesPassword");
+  this->ck().put_PbesPassword(value.c_str());
+}
+std::string HybridCrypt2::getPkcs7CryptAlg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Pkcs7CryptAlg(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setPkcs7CryptAlg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "pkcs7CryptAlg");
+  this->ck().put_Pkcs7CryptAlg(value.c_str());
+}
+double HybridCrypt2::getRc2EffectiveKeyLength() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Rc2EffectiveKeyLength());
+}
+void HybridCrypt2::setRc2EffectiveKeyLength(double value) {
+  this->beginCall();
+  this->ck().put_Rc2EffectiveKeyLength(rt::toInt(value, "rc2EffectiveKeyLength"));
+}
+std::string HybridCrypt2::getUuFilename() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UuFilename(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setUuFilename(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uuFilename");
+  this->ck().put_UuFilename(value.c_str());
+}
+std::string HybridCrypt2::getUuMode() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UuMode(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setUuMode(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uuMode");
+  this->ck().put_UuMode(value.c_str());
+}
+double HybridCrypt2::getBCryptWorkFactor() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_BCryptWorkFactor());
+}
+void HybridCrypt2::setBCryptWorkFactor(double value) {
+  this->beginCall();
+  this->ck().put_BCryptWorkFactor(rt::toInt(value, "bCryptWorkFactor"));
+}
+std::string HybridCrypt2::getSigningAlg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SigningAlg(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setSigningAlg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "signingAlg");
+  this->ck().put_SigningAlg(value.c_str());
+}
+std::string HybridCrypt2::getOaepHash() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OaepHash(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setOaepHash(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oaepHash");
+  this->ck().put_OaepHash(value.c_str());
+}
+bool HybridCrypt2::getOaepPadding() {
+  this->beginCall();
+  return this->ck().get_OaepPadding();
+}
+void HybridCrypt2::setOaepPadding(bool value) {
+  this->beginCall();
+  this->ck().put_OaepPadding(value);
+}
+std::string HybridCrypt2::getOaepMgfHash() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OaepMgfHash(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setOaepMgfHash(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oaepMgfHash");
+  this->ck().put_OaepMgfHash(value.c_str());
+}
+std::string HybridCrypt2::getSigningAttributes() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SigningAttributes(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setSigningAttributes(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "signingAttributes");
+  this->ck().put_SigningAttributes(value.c_str());
+}
+std::string HybridCrypt2::getCmsOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CmsOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setCmsOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "cmsOptions");
+  this->ck().put_CmsOptions(value.c_str());
+}
+std::string HybridCrypt2::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridCrypt2::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridCrypt2::addEncryptCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  addEncryptCert_impl(cert);
+}
+void HybridCrypt2::addEncryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->ck().AddEncryptCert(rt::implOf<HybridCert>(cert, "cert").ck());
+}
+
+void HybridCrypt2::addPfxSourceFile(const std::string& pfxFilePath, const std::string& pfxPassword) {
+  this->beginCall();
+  addPfxSourceFile_impl(pfxFilePath, pfxPassword);
+}
+void HybridCrypt2::addPfxSourceFile_impl(const std::string& pfxFilePath, const std::string& pfxPassword) {
+  rt::checkNoNul(pfxFilePath, "pfxFilePath");
+  rt::checkNoNul(pfxPassword, "pfxPassword");
+  if (!this->ck().AddPfxSourceFile(pfxFilePath.c_str(), pfxPassword.c_str())) throw this->fail("addPfxSourceFile");
+}
+
+void HybridCrypt2::ckDecryptFile(const std::string& srcFile, const std::string& destFile) {
+  this->beginCall();
+  ckDecryptFile_impl(srcFile, destFile);
+}
+void HybridCrypt2::ckDecryptFile_impl(const std::string& srcFile, const std::string& destFile) {
+  rt::checkNoNul(srcFile, "srcFile");
+  rt::checkNoNul(destFile, "destFile");
+  if (!this->ck().CkDecryptFile(srcFile.c_str(), destFile.c_str())) throw this->fail("ckDecryptFile");
+}
+std::shared_ptr<Promise<void>> HybridCrypt2::ckDecryptFileAsync(const std::string& srcFile, const std::string& destFile) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCrypt2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Crypt2.ckDecryptFileAsync", std::move(_parts), [_self, srcFile, destFile]() {
+    _self->ckDecryptFile_impl(srcFile, destFile);
+  });
+}
+
+void HybridCrypt2::ckEncryptFile(const std::string& srcFile, const std::string& destFile) {
+  this->beginCall();
+  ckEncryptFile_impl(srcFile, destFile);
+}
+void HybridCrypt2::ckEncryptFile_impl(const std::string& srcFile, const std::string& destFile) {
+  rt::checkNoNul(srcFile, "srcFile");
+  rt::checkNoNul(destFile, "destFile");
+  if (!this->ck().CkEncryptFile(srcFile.c_str(), destFile.c_str())) throw this->fail("ckEncryptFile");
+}
+std::shared_ptr<Promise<void>> HybridCrypt2::ckEncryptFileAsync(const std::string& srcFile, const std::string& destFile) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCrypt2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Crypt2.ckEncryptFileAsync", std::move(_parts), [_self, srcFile, destFile]() {
+    _self->ckEncryptFile_impl(srcFile, destFile);
+  });
+}
+
+void HybridCrypt2::clearEncryptCerts() {
+  this->beginCall();
+  clearEncryptCerts_impl();
+}
+void HybridCrypt2::clearEncryptCerts_impl() {
+  this->ck().ClearEncryptCerts();
+}
+
+double HybridCrypt2::crcFile(const std::string& crcAlg, const std::string& path) {
+  this->beginCall();
+  return crcFile_impl(crcAlg, path);
+}
+double HybridCrypt2::crcFile_impl(const std::string& crcAlg, const std::string& path) {
+  rt::checkNoNul(crcAlg, "crcAlg");
+  rt::checkNoNul(path, "path");
+  return static_cast<double>(this->ck().CrcFile(crcAlg.c_str(), path.c_str()));
+}
+std::shared_ptr<Promise<double>> HybridCrypt2::crcFileAsync(const std::string& crcAlg, const std::string& path) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCrypt2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Crypt2.crcFileAsync", std::move(_parts), [_self, crcAlg, path]() {
+    return _self->crcFile_impl(crcAlg, path);
+  });
+}
+
+void HybridCrypt2::createP7M(const std::string& inFilename, const std::string& p7mPath) {
+  this->beginCall();
+  createP7M_impl(inFilename, p7mPath);
+}
+void HybridCrypt2::createP7M_impl(const std::string& inFilename, const std::string& p7mPath) {
+  rt::checkNoNul(inFilename, "inFilename");
+  rt::checkNoNul(p7mPath, "p7mPath");
+  if (!this->ck().CreateP7M(inFilename.c_str(), p7mPath.c_str())) throw this->fail("createP7M");
+}
+std::shared_ptr<Promise<void>> HybridCrypt2::createP7MAsync(const std::string& inFilename, const std::string& p7mPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCrypt2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Crypt2.createP7MAsync", std::move(_parts), [_self, inFilename, p7mPath]() {
+    _self->createP7M_impl(inFilename, p7mPath);
+  });
+}
+
+void HybridCrypt2::createP7S(const std::string& inFilename, const std::string& p7sPath) {
+  this->beginCall();
+  createP7S_impl(inFilename, p7sPath);
+}
+void HybridCrypt2::createP7S_impl(const std::string& inFilename, const std::string& p7sPath) {
+  rt::checkNoNul(inFilename, "inFilename");
+  rt::checkNoNul(p7sPath, "p7sPath");
+  if (!this->ck().CreateP7S(inFilename.c_str(), p7sPath.c_str())) throw this->fail("createP7S");
+}
+std::shared_ptr<Promise<void>> HybridCrypt2::createP7SAsync(const std::string& inFilename, const std::string& p7sPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCrypt2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Crypt2.createP7SAsync", std::move(_parts), [_self, inFilename, p7sPath]() {
+    _self->createP7S_impl(inFilename, p7sPath);
+  });
+}
+
+std::string HybridCrypt2::decodeString(const std::string& inStr, const std::string& charset, const std::string& encoding) {
+  this->beginCall();
+  return decodeString_impl(inStr, charset, encoding);
+}
+std::string HybridCrypt2::decodeString_impl(const std::string& inStr, const std::string& charset, const std::string& encoding) {
+  rt::checkNoNul(inStr, "inStr");
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().DecodeString(inStr.c_str(), charset.c_str(), encoding.c_str(), _out)) throw this->fail("decodeString");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::decryptEncoded(const std::string& encodedEncryptedData) {
+  this->beginCall();
+  return decryptEncoded_impl(encodedEncryptedData);
+}
+std::string HybridCrypt2::decryptEncoded_impl(const std::string& encodedEncryptedData) {
+  rt::checkNoNul(encodedEncryptedData, "encodedEncryptedData");
+  CkString _out;
+  if (!this->ck().DecryptEncoded(encodedEncryptedData.c_str(), _out)) throw this->fail("decryptEncoded");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::decryptStringENC(const std::string& str) {
+  this->beginCall();
+  return decryptStringENC_impl(str);
+}
+std::string HybridCrypt2::decryptStringENC_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  CkString _out;
+  if (!this->ck().DecryptStringENC(str.c_str(), _out)) throw this->fail("decryptStringENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::encodeBytes(const std::shared_ptr<ArrayBuffer>& byteData, const std::string& encoding) {
+  this->beginCall();
+  rt::ByteView _byteData = rt::viewOf(byteData);
+  return encodeBytes_impl(_byteData.data, _byteData.size, encoding);
+}
+std::string HybridCrypt2::encodeBytes_impl(const uint8_t* byteDataData, size_t byteDataSize, const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().EncodeBytes(static_cast<const void*>(byteDataData), static_cast<unsigned long>(byteDataSize), encoding.c_str(), _out)) throw this->fail("encodeBytes");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::encodeString(const std::string& strToEncode, const std::string& charsetName, const std::string& toEncodingName) {
+  this->beginCall();
+  return encodeString_impl(strToEncode, charsetName, toEncodingName);
+}
+std::string HybridCrypt2::encodeString_impl(const std::string& strToEncode, const std::string& charsetName, const std::string& toEncodingName) {
+  rt::checkNoNul(strToEncode, "strToEncode");
+  rt::checkNoNul(charsetName, "charsetName");
+  rt::checkNoNul(toEncodingName, "toEncodingName");
+  CkString _out;
+  if (!this->ck().EncodeString(strToEncode.c_str(), charsetName.c_str(), toEncodingName.c_str(), _out)) throw this->fail("encodeString");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::encryptEncoded(const std::string& str) {
+  this->beginCall();
+  return encryptEncoded_impl(str);
+}
+std::string HybridCrypt2::encryptEncoded_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  CkString _out;
+  if (!this->ck().EncryptEncoded(str.c_str(), _out)) throw this->fail("encryptEncoded");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::encryptStringENC(const std::string& str) {
+  this->beginCall();
+  return encryptStringENC_impl(str);
+}
+std::string HybridCrypt2::encryptStringENC_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  CkString _out;
+  if (!this->ck().EncryptStringENC(str.c_str(), _out)) throw this->fail("encryptStringENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::genRandomBytesENC(double numBytes) {
+  this->beginCall();
+  return genRandomBytesENC_impl(numBytes);
+}
+std::string HybridCrypt2::genRandomBytesENC_impl(double numBytes) {
+  CkString _out;
+  if (!this->ck().GenRandomBytesENC(rt::toInt(numBytes, "numBytes"), _out)) throw this->fail("genRandomBytesENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::generateUuid() {
+  this->beginCall();
+  return generateUuid_impl();
+}
+std::string HybridCrypt2::generateUuid_impl() {
+  CkString _out;
+  if (!this->ck().GenerateUuid(_out)) throw this->fail("generateUuid");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::getEncodedAuthTag(const std::string& encoding) {
+  this->beginCall();
+  return getEncodedAuthTag_impl(encoding);
+}
+std::string HybridCrypt2::getEncodedAuthTag_impl(const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetEncodedAuthTag(encoding.c_str(), _out)) throw this->fail("getEncodedAuthTag");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::getEncodedIV(const std::string& encoding) {
+  this->beginCall();
+  return getEncodedIV_impl(encoding);
+}
+std::string HybridCrypt2::getEncodedIV_impl(const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetEncodedIV(encoding.c_str(), _out)) throw this->fail("getEncodedIV");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::getSignatureSigningTimeStr(double index) {
+  this->beginCall();
+  return getSignatureSigningTimeStr_impl(index);
+}
+std::string HybridCrypt2::getSignatureSigningTimeStr_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetSignatureSigningTimeStr(rt::toInt(index, "index"), _out)) throw this->fail("getSignatureSigningTimeStr");
+  return rt::stdString(_out);
+}
+
+bool HybridCrypt2::hasSignatureSigningTime(double index) {
+  this->beginCall();
+  return hasSignatureSigningTime_impl(index);
+}
+bool HybridCrypt2::hasSignatureSigningTime_impl(double index) {
+  return this->ck().HasSignatureSigningTime(rt::toInt(index, "index"));
+}
+
+void HybridCrypt2::hashBeginString(const std::string& strData) {
+  this->beginCall();
+  hashBeginString_impl(strData);
+}
+void HybridCrypt2::hashBeginString_impl(const std::string& strData) {
+  rt::checkNoNul(strData, "strData");
+  if (!this->ck().HashBeginString(strData.c_str())) throw this->fail("hashBeginString");
+}
+
+std::string HybridCrypt2::hashFileENC(const std::string& path) {
+  this->beginCall();
+  return hashFileENC_impl(path);
+}
+std::string HybridCrypt2::hashFileENC_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  CkString _out;
+  if (!this->ck().HashFileENC(path.c_str(), _out)) throw this->fail("hashFileENC");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridCrypt2::hashFileENCAsync(const std::string& path) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCrypt2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Crypt2.hashFileENCAsync", std::move(_parts), [_self, path]() {
+    return _self->hashFileENC_impl(path);
+  });
+}
+
+std::string HybridCrypt2::hashFinalENC() {
+  this->beginCall();
+  return hashFinalENC_impl();
+}
+std::string HybridCrypt2::hashFinalENC_impl() {
+  CkString _out;
+  if (!this->ck().HashFinalENC(_out)) throw this->fail("hashFinalENC");
+  return rt::stdString(_out);
+}
+
+void HybridCrypt2::hashMoreString(const std::string& strData) {
+  this->beginCall();
+  hashMoreString_impl(strData);
+}
+void HybridCrypt2::hashMoreString_impl(const std::string& strData) {
+  rt::checkNoNul(strData, "strData");
+  if (!this->ck().HashMoreString(strData.c_str())) throw this->fail("hashMoreString");
+}
+
+std::string HybridCrypt2::hashStringENC(const std::string& str) {
+  this->beginCall();
+  return hashStringENC_impl(str);
+}
+std::string HybridCrypt2::hashStringENC_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  CkString _out;
+  if (!this->ck().HashStringENC(str.c_str(), _out)) throw this->fail("hashStringENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::macStringENC(const std::string& inText) {
+  this->beginCall();
+  return macStringENC_impl(inText);
+}
+std::string HybridCrypt2::macStringENC_impl(const std::string& inText) {
+  rt::checkNoNul(inText, "inText");
+  CkString _out;
+  if (!this->ck().MacStringENC(inText.c_str(), _out)) throw this->fail("macStringENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::mySqlAesDecrypt(const std::string& strEncryptedHex, const std::string& strPassword) {
+  this->beginCall();
+  return mySqlAesDecrypt_impl(strEncryptedHex, strPassword);
+}
+std::string HybridCrypt2::mySqlAesDecrypt_impl(const std::string& strEncryptedHex, const std::string& strPassword) {
+  rt::checkNoNul(strEncryptedHex, "strEncryptedHex");
+  rt::checkNoNul(strPassword, "strPassword");
+  CkString _out;
+  if (!this->ck().MySqlAesDecrypt(strEncryptedHex.c_str(), strPassword.c_str(), _out)) throw this->fail("mySqlAesDecrypt");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::mySqlAesEncrypt(const std::string& strData, const std::string& strPassword) {
+  this->beginCall();
+  return mySqlAesEncrypt_impl(strData, strPassword);
+}
+std::string HybridCrypt2::mySqlAesEncrypt_impl(const std::string& strData, const std::string& strPassword) {
+  rt::checkNoNul(strData, "strData");
+  rt::checkNoNul(strPassword, "strPassword");
+  CkString _out;
+  if (!this->ck().MySqlAesEncrypt(strData.c_str(), strPassword.c_str(), _out)) throw this->fail("mySqlAesEncrypt");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::opaqueSignStringENC(const std::string& str) {
+  this->beginCall();
+  return opaqueSignStringENC_impl(str);
+}
+std::string HybridCrypt2::opaqueSignStringENC_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  CkString _out;
+  if (!this->ck().OpaqueSignStringENC(str.c_str(), _out)) throw this->fail("opaqueSignStringENC");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridCrypt2::opaqueSignStringENCAsync(const std::string& str) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCrypt2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Crypt2.opaqueSignStringENCAsync", std::move(_parts), [_self, str]() {
+    return _self->opaqueSignStringENC_impl(str);
+  });
+}
+
+std::string HybridCrypt2::opaqueVerifyStringENC(const std::string& p7m) {
+  this->beginCall();
+  return opaqueVerifyStringENC_impl(p7m);
+}
+std::string HybridCrypt2::opaqueVerifyStringENC_impl(const std::string& p7m) {
+  rt::checkNoNul(p7m, "p7m");
+  CkString _out;
+  if (!this->ck().OpaqueVerifyStringENC(p7m.c_str(), _out)) throw this->fail("opaqueVerifyStringENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::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) {
+  this->beginCall();
+  return pbkdf1_impl(password, charset, hashAlg, salt, iterationCount, outputKeyBitLen, encoding);
+}
+std::string HybridCrypt2::pbkdf1_impl(const std::string& password, const std::string& charset, const std::string& hashAlg, const std::string& salt, double iterationCount, double outputKeyBitLen, const std::string& encoding) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(hashAlg, "hashAlg");
+  rt::checkNoNul(salt, "salt");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().Pbkdf1(password.c_str(), charset.c_str(), hashAlg.c_str(), salt.c_str(), rt::toInt(iterationCount, "iterationCount"), rt::toInt(outputKeyBitLen, "outputKeyBitLen"), encoding.c_str(), _out)) throw this->fail("pbkdf1");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::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) {
+  this->beginCall();
+  return pbkdf2_impl(password, charset, hashAlg, salt, iterationCount, outputKeyBitLen, encoding);
+}
+std::string HybridCrypt2::pbkdf2_impl(const std::string& password, const std::string& charset, const std::string& hashAlg, const std::string& salt, double iterationCount, double outputKeyBitLen, const std::string& encoding) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(hashAlg, "hashAlg");
+  rt::checkNoNul(salt, "salt");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().Pbkdf2(password.c_str(), charset.c_str(), hashAlg.c_str(), salt.c_str(), rt::toInt(iterationCount, "iterationCount"), rt::toInt(outputKeyBitLen, "outputKeyBitLen"), encoding.c_str(), _out)) throw this->fail("pbkdf2");
+  return rt::stdString(_out);
+}
+
+void HybridCrypt2::randomizeIV() {
+  this->beginCall();
+  randomizeIV_impl();
+}
+void HybridCrypt2::randomizeIV_impl() {
+  this->ck().RandomizeIV();
+}
+
+std::string HybridCrypt2::reEncode(const std::string& encodedData, const std::string& fromEncoding, const std::string& toEncoding) {
+  this->beginCall();
+  return reEncode_impl(encodedData, fromEncoding, toEncoding);
+}
+std::string HybridCrypt2::reEncode_impl(const std::string& encodedData, const std::string& fromEncoding, const std::string& toEncoding) {
+  rt::checkNoNul(encodedData, "encodedData");
+  rt::checkNoNul(fromEncoding, "fromEncoding");
+  rt::checkNoNul(toEncoding, "toEncoding");
+  CkString _out;
+  if (!this->ck().ReEncode(encodedData.c_str(), fromEncoding.c_str(), toEncoding.c_str(), _out)) throw this->fail("reEncode");
+  return rt::stdString(_out);
+}
+
+void HybridCrypt2::setDecryptCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setDecryptCert_impl(cert);
+}
+void HybridCrypt2::setDecryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetDecryptCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setDecryptCert");
+}
+
+void HybridCrypt2::setDecryptCert2(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& key) {
+  this->beginCall();
+  setDecryptCert2_impl(cert, key);
+}
+void HybridCrypt2::setDecryptCert2_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& key) {
+  if (!this->ck().SetDecryptCert2(rt::implOf<HybridCert>(cert, "cert").ck(), rt::implOf<HybridPrivateKey>(key, "key").ck())) throw this->fail("setDecryptCert2");
+}
+
+void HybridCrypt2::setEncodedAad(const std::string& aadStr, const std::string& encoding) {
+  this->beginCall();
+  setEncodedAad_impl(aadStr, encoding);
+}
+void HybridCrypt2::setEncodedAad_impl(const std::string& aadStr, const std::string& encoding) {
+  rt::checkNoNul(aadStr, "aadStr");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().SetEncodedAad(aadStr.c_str(), encoding.c_str())) throw this->fail("setEncodedAad");
+}
+
+void HybridCrypt2::setEncodedAuthTag(const std::string& authTagStr, const std::string& encoding) {
+  this->beginCall();
+  setEncodedAuthTag_impl(authTagStr, encoding);
+}
+void HybridCrypt2::setEncodedAuthTag_impl(const std::string& authTagStr, const std::string& encoding) {
+  rt::checkNoNul(authTagStr, "authTagStr");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().SetEncodedAuthTag(authTagStr.c_str(), encoding.c_str())) throw this->fail("setEncodedAuthTag");
+}
+
+void HybridCrypt2::setEncodedIV(const std::string& ivStr, const std::string& encoding) {
+  this->beginCall();
+  setEncodedIV_impl(ivStr, encoding);
+}
+void HybridCrypt2::setEncodedIV_impl(const std::string& ivStr, const std::string& encoding) {
+  rt::checkNoNul(ivStr, "ivStr");
+  rt::checkNoNul(encoding, "encoding");
+  this->ck().SetEncodedIV(ivStr.c_str(), encoding.c_str());
+}
+
+void HybridCrypt2::setEncodedKey(const std::string& keyStr, const std::string& encoding) {
+  this->beginCall();
+  setEncodedKey_impl(keyStr, encoding);
+}
+void HybridCrypt2::setEncodedKey_impl(const std::string& keyStr, const std::string& encoding) {
+  rt::checkNoNul(keyStr, "keyStr");
+  rt::checkNoNul(encoding, "encoding");
+  this->ck().SetEncodedKey(keyStr.c_str(), encoding.c_str());
+}
+
+void HybridCrypt2::setEncodedSalt(const std::string& saltStr, const std::string& encoding) {
+  this->beginCall();
+  setEncodedSalt_impl(saltStr, encoding);
+}
+void HybridCrypt2::setEncodedSalt_impl(const std::string& saltStr, const std::string& encoding) {
+  rt::checkNoNul(saltStr, "saltStr");
+  rt::checkNoNul(encoding, "encoding");
+  this->ck().SetEncodedSalt(saltStr.c_str(), encoding.c_str());
+}
+
+void HybridCrypt2::setEncryptCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setEncryptCert_impl(cert);
+}
+void HybridCrypt2::setEncryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetEncryptCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setEncryptCert");
+}
+
+void HybridCrypt2::setIV(const std::shared_ptr<ArrayBuffer>& byteData) {
+  this->beginCall();
+  rt::ByteView _byteData = rt::viewOf(byteData);
+  setIV_impl(_byteData.data, _byteData.size);
+}
+void HybridCrypt2::setIV_impl(const uint8_t* byteDataData, size_t byteDataSize) {
+  this->ck().SetIV(static_cast<const void*>(byteDataData), static_cast<unsigned long>(byteDataSize));
+}
+
+void HybridCrypt2::setMacKeyEncoded(const std::string& key, const std::string& encoding) {
+  this->beginCall();
+  setMacKeyEncoded_impl(key, encoding);
+}
+void HybridCrypt2::setMacKeyEncoded_impl(const std::string& key, const std::string& encoding) {
+  rt::checkNoNul(key, "key");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().SetMacKeyEncoded(key.c_str(), encoding.c_str())) throw this->fail("setMacKeyEncoded");
+}
+
+void HybridCrypt2::setMacKeyString(const std::string& key) {
+  this->beginCall();
+  setMacKeyString_impl(key);
+}
+void HybridCrypt2::setMacKeyString_impl(const std::string& key) {
+  rt::checkNoNul(key, "key");
+  if (!this->ck().SetMacKeyString(key.c_str())) throw this->fail("setMacKeyString");
+}
+
+void HybridCrypt2::setSecretKey(const std::shared_ptr<ArrayBuffer>& byteData) {
+  this->beginCall();
+  rt::ByteView _byteData = rt::viewOf(byteData);
+  setSecretKey_impl(_byteData.data, _byteData.size);
+}
+void HybridCrypt2::setSecretKey_impl(const uint8_t* byteDataData, size_t byteDataSize) {
+  this->ck().SetSecretKey(static_cast<const void*>(byteDataData), static_cast<unsigned long>(byteDataSize));
+}
+
+void HybridCrypt2::setSigningCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setSigningCert_impl(cert);
+}
+void HybridCrypt2::setSigningCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetSigningCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setSigningCert");
+}
+
+void HybridCrypt2::setSigningCert2(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) {
+  this->beginCall();
+  setSigningCert2_impl(cert, privateKey);
+}
+void HybridCrypt2::setSigningCert2_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) {
+  if (!this->ck().SetSigningCert2(rt::implOf<HybridCert>(cert, "cert").ck(), rt::implOf<HybridPrivateKey>(privateKey, "privateKey").ck())) throw this->fail("setSigningCert2");
+}
+
+void HybridCrypt2::setVerifyCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setVerifyCert_impl(cert);
+}
+void HybridCrypt2::setVerifyCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetVerifyCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setVerifyCert");
+}
+
+std::string HybridCrypt2::signStringENC(const std::string& str) {
+  this->beginCall();
+  return signStringENC_impl(str);
+}
+std::string HybridCrypt2::signStringENC_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  CkString _out;
+  if (!this->ck().SignStringENC(str.c_str(), _out)) throw this->fail("signStringENC");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridCrypt2::signStringENCAsync(const std::string& str) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCrypt2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Crypt2.signStringENCAsync", std::move(_parts), [_self, str]() {
+    return _self->signStringENC_impl(str);
+  });
+}
+
+void HybridCrypt2::useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  this->beginCall();
+  useCertVault_impl(vault);
+}
+void HybridCrypt2::useCertVault_impl(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  if (!this->ck().UseCertVault(rt::implOf<HybridXmlCertVault>(vault, "vault").ck())) throw this->fail("useCertVault");
+}
+
+void HybridCrypt2::verifyP7M(const std::string& p7mPath, const std::string& destPath) {
+  this->beginCall();
+  verifyP7M_impl(p7mPath, destPath);
+}
+void HybridCrypt2::verifyP7M_impl(const std::string& p7mPath, const std::string& destPath) {
+  rt::checkNoNul(p7mPath, "p7mPath");
+  rt::checkNoNul(destPath, "destPath");
+  if (!this->ck().VerifyP7M(p7mPath.c_str(), destPath.c_str())) throw this->fail("verifyP7M");
+}
+
+void HybridCrypt2::verifyP7S(const std::string& originalDataPath, const std::string& p7sPath) {
+  this->beginCall();
+  verifyP7S_impl(originalDataPath, p7sPath);
+}
+void HybridCrypt2::verifyP7S_impl(const std::string& originalDataPath, const std::string& p7sPath) {
+  rt::checkNoNul(originalDataPath, "originalDataPath");
+  rt::checkNoNul(p7sPath, "p7sPath");
+  if (!this->ck().VerifyP7S(originalDataPath.c_str(), p7sPath.c_str())) throw this->fail("verifyP7S");
+}
+
+void HybridCrypt2::verifyStringENC(const std::string& str, const std::string& encodedSig) {
+  this->beginCall();
+  verifyStringENC_impl(str, encodedSig);
+}
+void HybridCrypt2::verifyStringENC_impl(const std::string& str, const std::string& encodedSig) {
+  rt::checkNoNul(str, "str");
+  rt::checkNoNul(encodedSig, "encodedSig");
+  if (!this->ck().VerifyStringENC(str.c_str(), encodedSig.c_str())) throw this->fail("verifyStringENC");
+}
+
+std::string HybridCrypt2::bCryptHash(const std::string& password) {
+  this->beginCall();
+  return bCryptHash_impl(password);
+}
+std::string HybridCrypt2::bCryptHash_impl(const std::string& password) {
+  rt::checkNoNul(password, "password");
+  CkString _out;
+  if (!this->ck().BCryptHash(password.c_str(), _out)) throw this->fail("bCryptHash");
+  return rt::stdString(_out);
+}
+
+void HybridCrypt2::bCryptVerify(const std::string& password, const std::string& bcryptHash) {
+  this->beginCall();
+  bCryptVerify_impl(password, bcryptHash);
+}
+void HybridCrypt2::bCryptVerify_impl(const std::string& password, const std::string& bcryptHash) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(bcryptHash, "bcryptHash");
+  if (!this->ck().BCryptVerify(password.c_str(), bcryptHash.c_str())) throw this->fail("bCryptVerify");
+}
+
+std::string HybridCrypt2::aesKeyWrap(const std::string& kek, const std::string& keyData, const std::string& encoding) {
+  this->beginCall();
+  return aesKeyWrap_impl(kek, keyData, encoding);
+}
+std::string HybridCrypt2::aesKeyWrap_impl(const std::string& kek, const std::string& keyData, const std::string& encoding) {
+  rt::checkNoNul(kek, "kek");
+  rt::checkNoNul(keyData, "keyData");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().AesKeyWrap(kek.c_str(), keyData.c_str(), encoding.c_str(), _out)) throw this->fail("aesKeyWrap");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::aesKeyUnwrap(const std::string& kek, const std::string& wrappedKeyData, const std::string& encoding) {
+  this->beginCall();
+  return aesKeyUnwrap_impl(kek, wrappedKeyData, encoding);
+}
+std::string HybridCrypt2::aesKeyUnwrap_impl(const std::string& kek, const std::string& wrappedKeyData, const std::string& encoding) {
+  rt::checkNoNul(kek, "kek");
+  rt::checkNoNul(wrappedKeyData, "wrappedKeyData");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().AesKeyUnwrap(kek.c_str(), wrappedKeyData.c_str(), encoding.c_str(), _out)) throw this->fail("aesKeyUnwrap");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::hashBdENC(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  return hashBdENC_impl(bd);
+}
+std::string HybridCrypt2::hashBdENC_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  CkString _out;
+  if (!this->ck().HashBdENC(rt::implOf<HybridBinData>(bd, "bd").ck(), _out)) throw this->fail("hashBdENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::macBdENC(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  return macBdENC_impl(bd);
+}
+std::string HybridCrypt2::macBdENC_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  CkString _out;
+  if (!this->ck().MacBdENC(rt::implOf<HybridBinData>(bd, "bd").ck(), _out)) throw this->fail("macBdENC");
+  return rt::stdString(_out);
+}
+
+void HybridCrypt2::encryptBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  encryptBd_impl(bd);
+}
+void HybridCrypt2::encryptBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().EncryptBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("encryptBd");
+}
+
+void HybridCrypt2::decryptBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  decryptBd_impl(bd);
+}
+void HybridCrypt2::decryptBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().DecryptBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("decryptBd");
+}
+
+void HybridCrypt2::encryptSb(const std::shared_ptr<HybridStringBuilderSpec>& sbIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) {
+  this->beginCall();
+  encryptSb_impl(sbIn, bdOut);
+}
+void HybridCrypt2::encryptSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) {
+  if (!this->ck().EncryptSb(rt::implOf<HybridStringBuilder>(sbIn, "sbIn").ck(), rt::implOf<HybridBinData>(bdOut, "bdOut").ck())) throw this->fail("encryptSb");
+}
+
+void HybridCrypt2::decryptSb(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridStringBuilderSpec>& sbOut) {
+  this->beginCall();
+  decryptSb_impl(bdIn, sbOut);
+}
+void HybridCrypt2::decryptSb_impl(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridStringBuilderSpec>& sbOut) {
+  if (!this->ck().DecryptSb(rt::implOf<HybridBinData>(bdIn, "bdIn").ck(), rt::implOf<HybridStringBuilder>(sbOut, "sbOut").ck())) throw this->fail("decryptSb");
+}
+
+std::string HybridCrypt2::signBdENC(const std::shared_ptr<HybridBinDataSpec>& dataToSign) {
+  this->beginCall();
+  return signBdENC_impl(dataToSign);
+}
+std::string HybridCrypt2::signBdENC_impl(const std::shared_ptr<HybridBinDataSpec>& dataToSign) {
+  CkString _out;
+  if (!this->ck().SignBdENC(rt::implOf<HybridBinData>(dataToSign, "dataToSign").ck(), _out)) throw this->fail("signBdENC");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridCrypt2::signBdENCAsync(const std::shared_ptr<HybridBinDataSpec>& dataToSign) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCrypt2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(dataToSign);
+  return rt::runAsync<std::string>("Crypt2.signBdENCAsync", std::move(_parts), [_self, dataToSign]() {
+    return _self->signBdENC_impl(dataToSign);
+  });
+}
+
+std::string HybridCrypt2::signSbENC(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  return signSbENC_impl(sb);
+}
+std::string HybridCrypt2::signSbENC_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  CkString _out;
+  if (!this->ck().SignSbENC(rt::implOf<HybridStringBuilder>(sb, "sb").ck(), _out)) throw this->fail("signSbENC");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridCrypt2::signSbENCAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCrypt2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<std::string>("Crypt2.signSbENCAsync", std::move(_parts), [_self, sb]() {
+    return _self->signSbENC_impl(sb);
+  });
+}
+
+void HybridCrypt2::opaqueSignBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  opaqueSignBd_impl(bd);
+}
+void HybridCrypt2::opaqueSignBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().OpaqueSignBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("opaqueSignBd");
+}
+std::shared_ptr<Promise<void>> HybridCrypt2::opaqueSignBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCrypt2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("Crypt2.opaqueSignBdAsync", std::move(_parts), [_self, bd]() {
+    _self->opaqueSignBd_impl(bd);
+  });
+}
+
+void HybridCrypt2::opaqueVerifyBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  opaqueVerifyBd_impl(bd);
+}
+void HybridCrypt2::opaqueVerifyBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().OpaqueVerifyBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("opaqueVerifyBd");
+}
+
+void HybridCrypt2::verifyBdENC(const std::shared_ptr<HybridBinDataSpec>& data, const std::string& encodedSig) {
+  this->beginCall();
+  verifyBdENC_impl(data, encodedSig);
+}
+void HybridCrypt2::verifyBdENC_impl(const std::shared_ptr<HybridBinDataSpec>& data, const std::string& encodedSig) {
+  rt::checkNoNul(encodedSig, "encodedSig");
+  if (!this->ck().VerifyBdENC(rt::implOf<HybridBinData>(data, "data").ck(), encodedSig.c_str())) throw this->fail("verifyBdENC");
+}
+
+void HybridCrypt2::verifySbENC(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& encodedSig) {
+  this->beginCall();
+  verifySbENC_impl(sb, encodedSig);
+}
+void HybridCrypt2::verifySbENC_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& encodedSig) {
+  rt::checkNoNul(encodedSig, "encodedSig");
+  if (!this->ck().VerifySbENC(rt::implOf<HybridStringBuilder>(sb, "sb").ck(), encodedSig.c_str())) throw this->fail("verifySbENC");
+}
+
+std::string HybridCrypt2::encryptSecureENC(const std::shared_ptr<HybridSecureStringSpec>& secureStr) {
+  this->beginCall();
+  return encryptSecureENC_impl(secureStr);
+}
+std::string HybridCrypt2::encryptSecureENC_impl(const std::shared_ptr<HybridSecureStringSpec>& secureStr) {
+  CkString _out;
+  if (!this->ck().EncryptSecureENC(rt::implOf<HybridSecureString>(secureStr, "secureStr").ck(), _out)) throw this->fail("encryptSecureENC");
+  return rt::stdString(_out);
+}
+
+void HybridCrypt2::decryptSecureENC(const std::string& cipherText, const std::shared_ptr<HybridSecureStringSpec>& secureStr) {
+  this->beginCall();
+  decryptSecureENC_impl(cipherText, secureStr);
+}
+void HybridCrypt2::decryptSecureENC_impl(const std::string& cipherText, const std::shared_ptr<HybridSecureStringSpec>& secureStr) {
+  rt::checkNoNul(cipherText, "cipherText");
+  if (!this->ck().DecryptSecureENC(cipherText.c_str(), rt::implOf<HybridSecureString>(secureStr, "secureStr").ck())) throw this->fail("decryptSecureENC");
+}
+
+bool HybridCrypt2::getSignedAttributes(double signerIndex, const std::shared_ptr<HybridBinDataSpec>& pkcs7Der, const std::shared_ptr<HybridStringBuilderSpec>& sbJson) {
+  this->beginCall();
+  return getSignedAttributes_impl(signerIndex, pkcs7Der, sbJson);
+}
+bool HybridCrypt2::getSignedAttributes_impl(double signerIndex, const std::shared_ptr<HybridBinDataSpec>& pkcs7Der, const std::shared_ptr<HybridStringBuilderSpec>& sbJson) {
+  return this->ck().GetSignedAttributes(rt::toInt(signerIndex, "signerIndex"), rt::implOf<HybridBinData>(pkcs7Der, "pkcs7Der").ck(), rt::implOf<HybridStringBuilder>(sbJson, "sbJson").ck());
+}
+
+std::string HybridCrypt2::hotp(const std::string& secret, const std::string& secretEnc, const std::string& counterHex, double numDigits, double truncOffset, const std::string& hashAlg) {
+  this->beginCall();
+  return hotp_impl(secret, secretEnc, counterHex, numDigits, truncOffset, hashAlg);
+}
+std::string HybridCrypt2::hotp_impl(const std::string& secret, const std::string& secretEnc, const std::string& counterHex, double numDigits, double truncOffset, const std::string& hashAlg) {
+  rt::checkNoNul(secret, "secret");
+  rt::checkNoNul(secretEnc, "secretEnc");
+  rt::checkNoNul(counterHex, "counterHex");
+  rt::checkNoNul(hashAlg, "hashAlg");
+  CkString _out;
+  if (!this->ck().Hotp(secret.c_str(), secretEnc.c_str(), counterHex.c_str(), rt::toInt(numDigits, "numDigits"), rt::toInt(truncOffset, "truncOffset"), hashAlg.c_str(), _out)) throw this->fail("hotp");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::encodeInt(double value, double numBytes, bool littleEndian, const std::string& encoding) {
+  this->beginCall();
+  return encodeInt_impl(value, numBytes, littleEndian, encoding);
+}
+std::string HybridCrypt2::encodeInt_impl(double value, double numBytes, bool littleEndian, const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().EncodeInt(rt::toInt(value, "value"), rt::toInt(numBytes, "numBytes"), littleEndian, encoding.c_str(), _out)) throw this->fail("encodeInt");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::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) {
+  this->beginCall();
+  return totp_impl(secret, secretEnc, t0, tNow, tStep, numDigits, truncOffset, hashAlg);
+}
+std::string HybridCrypt2::totp_impl(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) {
+  rt::checkNoNul(secret, "secret");
+  rt::checkNoNul(secretEnc, "secretEnc");
+  rt::checkNoNul(t0, "t0");
+  rt::checkNoNul(tNow, "tNow");
+  rt::checkNoNul(hashAlg, "hashAlg");
+  CkString _out;
+  if (!this->ck().Totp(secret.c_str(), secretEnc.c_str(), t0.c_str(), tNow.c_str(), rt::toInt(tStep, "tStep"), rt::toInt(numDigits, "numDigits"), rt::toInt(truncOffset, "truncOffset"), hashAlg.c_str(), _out)) throw this->fail("totp");
+  return rt::stdString(_out);
+}
+
+void HybridCrypt2::setTsaHttpObj(const std::shared_ptr<HybridHttpSpec>& http) {
+  this->beginCall();
+  setTsaHttpObj_impl(http);
+}
+void HybridCrypt2::setTsaHttpObj_impl(const std::shared_ptr<HybridHttpSpec>& http) {
+  this->ck().SetTsaHttpObj(rt::implOf<HybridHttp>(http, "http").ck());
+}
+
+void HybridCrypt2::hashBeginBytes2(const std::shared_ptr<ArrayBuffer>& byteData) {
+  this->beginCall();
+  rt::ByteView _byteData = rt::viewOf(byteData);
+  hashBeginBytes2_impl(_byteData.data, _byteData.size);
+}
+void HybridCrypt2::hashBeginBytes2_impl(const uint8_t* byteDataData, size_t byteDataSize) {
+  if (!this->ck().HashBeginBytes2(static_cast<const void*>(byteDataData), static_cast<unsigned long>(byteDataSize))) throw this->fail("hashBeginBytes2");
+}
+
+void HybridCrypt2::hashMoreBytes2(const std::shared_ptr<ArrayBuffer>& byteData) {
+  this->beginCall();
+  rt::ByteView _byteData = rt::viewOf(byteData);
+  hashMoreBytes2_impl(_byteData.data, _byteData.size);
+}
+void HybridCrypt2::hashMoreBytes2_impl(const uint8_t* byteDataData, size_t byteDataSize) {
+  if (!this->ck().HashMoreBytes2(static_cast<const void*>(byteDataData), static_cast<unsigned long>(byteDataSize))) throw this->fail("hashMoreBytes2");
+}
+
+void HybridCrypt2::addSigningCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  addSigningCert_impl(cert);
+}
+void HybridCrypt2::addSigningCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().AddSigningCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("addSigningCert");
+}
+
+void HybridCrypt2::clearSigningCerts() {
+  this->beginCall();
+  clearSigningCerts_impl();
+}
+void HybridCrypt2::clearSigningCerts_impl() {
+  this->ck().ClearSigningCerts();
+}
+
+void HybridCrypt2::coSign(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridBinDataSpec>& bdOut) {
+  this->beginCall();
+  coSign_impl(bdIn, cert, bdOut);
+}
+void HybridCrypt2::coSign_impl(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridBinDataSpec>& bdOut) {
+  if (!this->ck().CoSign(rt::implOf<HybridBinData>(bdIn, "bdIn").ck(), rt::implOf<HybridCert>(cert, "cert").ck(), rt::implOf<HybridBinData>(bdOut, "bdOut").ck())) throw this->fail("coSign");
+}
+
+std::string HybridCrypt2::signHashENC(const std::string& encodedHash, const std::string& hashAlg, const std::string& hashEncoding) {
+  this->beginCall();
+  return signHashENC_impl(encodedHash, hashAlg, hashEncoding);
+}
+std::string HybridCrypt2::signHashENC_impl(const std::string& encodedHash, const std::string& hashAlg, const std::string& hashEncoding) {
+  rt::checkNoNul(encodedHash, "encodedHash");
+  rt::checkNoNul(hashAlg, "hashAlg");
+  rt::checkNoNul(hashEncoding, "hashEncoding");
+  CkString _out;
+  if (!this->ck().SignHashENC(encodedHash.c_str(), hashAlg.c_str(), hashEncoding.c_str(), _out)) throw this->fail("signHashENC");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridCrypt2::signHashENCAsync(const std::string& encodedHash, const std::string& hashAlg, const std::string& hashEncoding) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCrypt2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Crypt2.signHashENCAsync", std::move(_parts), [_self, encodedHash, hashAlg, hashEncoding]() {
+    return _self->signHashENC_impl(encodedHash, hashAlg, hashEncoding);
+  });
+}
+
+void HybridCrypt2::xtsSetEncodedTweakValue(const std::string& tweak, const std::string& encoding) {
+  this->beginCall();
+  xtsSetEncodedTweakValue_impl(tweak, encoding);
+}
+void HybridCrypt2::xtsSetEncodedTweakValue_impl(const std::string& tweak, const std::string& encoding) {
+  rt::checkNoNul(tweak, "tweak");
+  rt::checkNoNul(encoding, "encoding");
+  this->ck().XtsSetEncodedTweakValue(tweak.c_str(), encoding.c_str());
+}
+
+void HybridCrypt2::xtsSetDataUnitNumber(double loUint32, double hiUint32) {
+  this->beginCall();
+  xtsSetDataUnitNumber_impl(loUint32, hiUint32);
+}
+void HybridCrypt2::xtsSetDataUnitNumber_impl(double loUint32, double hiUint32) {
+  this->ck().XtsSetDataUnitNumber(rt::toULong(loUint32, "loUint32"), rt::toULong(hiUint32, "hiUint32"));
+}
+
+void HybridCrypt2::xtsSetEncodedTweakKey(const std::string& key, const std::string& encoding) {
+  this->beginCall();
+  xtsSetEncodedTweakKey_impl(key, encoding);
+}
+void HybridCrypt2::xtsSetEncodedTweakKey_impl(const std::string& key, const std::string& encoding) {
+  rt::checkNoNul(key, "key");
+  rt::checkNoNul(encoding, "encoding");
+  this->ck().XtsSetEncodedTweakKey(key.c_str(), encoding.c_str());
+}
+
+std::string HybridCrypt2::aesKeyWrapWithPadding(const std::string& kek, const std::string& keyData, const std::string& encoding) {
+  this->beginCall();
+  return aesKeyWrapWithPadding_impl(kek, keyData, encoding);
+}
+std::string HybridCrypt2::aesKeyWrapWithPadding_impl(const std::string& kek, const std::string& keyData, const std::string& encoding) {
+  rt::checkNoNul(kek, "kek");
+  rt::checkNoNul(keyData, "keyData");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().AesKeyWrapWithPadding(kek.c_str(), keyData.c_str(), encoding.c_str(), _out)) throw this->fail("aesKeyWrapWithPadding");
+  return rt::stdString(_out);
+}
+
+std::string HybridCrypt2::aesKeyUnwrapWithPadding(const std::string& kek, const std::string& wrappedKeyData, const std::string& encoding) {
+  this->beginCall();
+  return aesKeyUnwrapWithPadding_impl(kek, wrappedKeyData, encoding);
+}
+std::string HybridCrypt2::aesKeyUnwrapWithPadding_impl(const std::string& kek, const std::string& wrappedKeyData, const std::string& encoding) {
+  rt::checkNoNul(kek, "kek");
+  rt::checkNoNul(wrappedKeyData, "wrappedKeyData");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().AesKeyUnwrapWithPadding(kek.c_str(), wrappedKeyData.c_str(), encoding.c_str(), _out)) throw this->fail("aesKeyUnwrapWithPadding");
+  return rt::stdString(_out);
+}
+
+void HybridCrypt2::getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getLastJsonData_impl(json);
+}
+void HybridCrypt2::getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->ck().GetLastJsonData(rt::implOf<HybridJsonObject>(json, "json").ck());
+}
+
+void HybridCrypt2::lastDecryptCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  lastDecryptCert_impl(cert);
+}
+void HybridCrypt2::lastDecryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().LastDecryptCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("lastDecryptCert");
+}
+
+void HybridCrypt2::lastSignerCert(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  lastSignerCert_impl(index, cert);
+}
+void HybridCrypt2::lastSignerCert_impl(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().LastSignerCert(rt::toInt(index, "index"), rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("lastSignerCert");
+}
+
+void HybridCrypt2::addPfxSourceBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) {
+  this->beginCall();
+  addPfxSourceBd_impl(bd, password);
+}
+void HybridCrypt2::addPfxSourceBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().AddPfxSourceBd(rt::implOf<HybridBinData>(bd, "bd").ck(), password.c_str())) throw this->fail("addPfxSourceBd");
+}
+
+double HybridCrypt2::crcBd(const std::string& crcAlg, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  return crcBd_impl(crcAlg, bd);
+}
+double HybridCrypt2::crcBd_impl(const std::string& crcAlg, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(crcAlg, "crcAlg");
+  return static_cast<double>(this->ck().CrcBd(crcAlg.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck()));
+}
+
+void HybridCrypt2::hashChunkBd(bool firstChunk, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  hashChunkBd_impl(firstChunk, bd);
+}
+void HybridCrypt2::hashChunkBd_impl(bool firstChunk, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().HashChunkBd(firstChunk, rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("hashChunkBd");
+}
+
+void HybridCrypt2::argon2DeriveKey(const std::string& password, const std::string& json, const std::shared_ptr<HybridBinDataSpec>& bdKey) {
+  this->beginCall();
+  argon2DeriveKey_impl(password, json, bdKey);
+}
+void HybridCrypt2::argon2DeriveKey_impl(const std::string& password, const std::string& json, const std::shared_ptr<HybridBinDataSpec>& bdKey) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(json, "json");
+  if (!this->ck().Argon2DeriveKey(password.c_str(), json.c_str(), rt::implOf<HybridBinData>(bdKey, "bdKey").ck())) throw this->fail("argon2DeriveKey");
+}
+
+std::string HybridCrypt2::argon2HashPassword(const std::string& password, const std::string& json) {
+  this->beginCall();
+  return argon2HashPassword_impl(password, json);
+}
+std::string HybridCrypt2::argon2HashPassword_impl(const std::string& password, const std::string& json) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(json, "json");
+  CkString _out;
+  if (!this->ck().Argon2HashPassword(password.c_str(), json.c_str(), _out)) throw this->fail("argon2HashPassword");
+  return rt::stdString(_out);
+}
+
+double HybridCrypt2::argon2VerifyPassword(const std::string& password, const std::string& json, const std::string& phcHash) {
+  this->beginCall();
+  return argon2VerifyPassword_impl(password, json, phcHash);
+}
+double HybridCrypt2::argon2VerifyPassword_impl(const std::string& password, const std::string& json, const std::string& phcHash) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(json, "json");
+  rt::checkNoNul(phcHash, "phcHash");
+  return static_cast<double>(this->ck().Argon2VerifyPassword(password.c_str(), json.c_str(), phcHash.c_str()));
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridCrypt2::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridCrypt2::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridCrypt2::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridCrypt2::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridCrypt2::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat