@chilkat/react-native 11.6.1

package/cpp/HybridCert.cpp

@@ -0,0 +1,840 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridCert.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCertChain.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridPkcs11.hpp"
+#include "HybridPrivateKey.hpp"
+#include "HybridPublicKey.hpp"
+#include "HybridXmlCertVault.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridCert::HybridCert()
+    : HybridObject(HybridCertSpec::TAG), ChilkatObject<CkCert>("Cert", CkCert::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridCert::HybridCert(CkCert* owned)
+    : HybridObject(HybridCertSpec::TAG), ChilkatObject<CkCert>("Cert", owned) {
+  init();
+}
+
+void HybridCert::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridCert::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridCert::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridCert::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridCert::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridCert::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridCert::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridCert::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridCert::getAuthorityKeyId() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AuthorityKeyId(_s);
+  return rt::stdString(_s);
+}
+bool HybridCert::getAvoidWindowsPkAccess() {
+  this->beginCall();
+  return this->ck().get_AvoidWindowsPkAccess();
+}
+void HybridCert::setAvoidWindowsPkAccess(bool value) {
+  this->beginCall();
+  this->ck().put_AvoidWindowsPkAccess(value);
+}
+double HybridCert::getCertVersion() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_CertVersion());
+}
+bool HybridCert::getExpired() {
+  this->beginCall();
+  return this->ck().get_Expired();
+}
+bool HybridCert::getForClientAuthentication() {
+  this->beginCall();
+  return this->ck().get_ForClientAuthentication();
+}
+bool HybridCert::getForCodeSigning() {
+  this->beginCall();
+  return this->ck().get_ForCodeSigning();
+}
+bool HybridCert::getForSecureEmail() {
+  this->beginCall();
+  return this->ck().get_ForSecureEmail();
+}
+bool HybridCert::getForServerAuthentication() {
+  this->beginCall();
+  return this->ck().get_ForServerAuthentication();
+}
+bool HybridCert::getForTimeStamping() {
+  this->beginCall();
+  return this->ck().get_ForTimeStamping();
+}
+double HybridCert::getIntendedKeyUsage() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_IntendedKeyUsage());
+}
+bool HybridCert::getIsRoot() {
+  this->beginCall();
+  return this->ck().get_IsRoot();
+}
+std::string HybridCert::getIssuerC() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_IssuerC(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getIssuerCN() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_IssuerCN(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getIssuerDN() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_IssuerDN(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getIssuerE() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_IssuerE(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getIssuerL() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_IssuerL(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getIssuerO() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_IssuerO(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getIssuerOU() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_IssuerOU(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getIssuerS() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_IssuerS(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getOcspUrl() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OcspUrl(_s);
+  return rt::stdString(_s);
+}
+bool HybridCert::getPrivateKeyExportable() {
+  this->beginCall();
+  return this->ck().get_PrivateKeyExportable();
+}
+bool HybridCert::getRevoked() {
+  this->beginCall();
+  return this->ck().get_Revoked();
+}
+std::string HybridCert::getRfc822Name() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Rfc822Name(_s);
+  return rt::stdString(_s);
+}
+bool HybridCert::getSelfSigned() {
+  this->beginCall();
+  return this->ck().get_SelfSigned();
+}
+std::string HybridCert::getSerialNumber() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SerialNumber(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getSha1Thumbprint() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Sha1Thumbprint(_s);
+  return rt::stdString(_s);
+}
+bool HybridCert::getSignatureVerified() {
+  this->beginCall();
+  return this->ck().get_SignatureVerified();
+}
+std::string HybridCert::getSubjectC() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SubjectC(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getSubjectCN() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SubjectCN(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getSubjectDN() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SubjectDN(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getSubjectE() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SubjectE(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getSubjectKeyId() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SubjectKeyId(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getSubjectL() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SubjectL(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getSubjectO() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SubjectO(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getSubjectOU() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SubjectOU(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getSubjectS() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SubjectS(_s);
+  return rt::stdString(_s);
+}
+bool HybridCert::getTrustedRoot() {
+  this->beginCall();
+  return this->ck().get_TrustedRoot();
+}
+std::string HybridCert::getValidFromStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ValidFromStr(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getValidToStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ValidToStr(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getSerialDecimal() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SerialDecimal(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getSmartCardPin() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SmartCardPin(_s);
+  return rt::stdString(_s);
+}
+void HybridCert::setSmartCardPin(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "smartCardPin");
+  this->ck().put_SmartCardPin(value.c_str());
+}
+bool HybridCert::getSmartCardNoDialog() {
+  this->beginCall();
+  return this->ck().get_SmartCardNoDialog();
+}
+void HybridCert::setSmartCardNoDialog(bool value) {
+  this->beginCall();
+  this->ck().put_SmartCardNoDialog(value);
+}
+std::string HybridCert::getExtendedKeyUsage() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ExtendedKeyUsage(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getSubjectAlternativeName() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SubjectAlternativeName(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCert::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridCert::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+double HybridCert::getSmartCardFailReason() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SmartCardFailReason());
+}
+
+// ---- Methods ----
+
+double HybridCert::checkRevoked() {
+  this->beginCall();
+  return checkRevoked_impl();
+}
+double HybridCert::checkRevoked_impl() {
+  return static_cast<double>(this->ck().CheckRevoked());
+}
+
+void HybridCert::exportCertDerFile(const std::string& path) {
+  this->beginCall();
+  exportCertDerFile_impl(path);
+}
+void HybridCert::exportCertDerFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().ExportCertDerFile(path.c_str())) throw this->fail("exportCertDerFile");
+}
+
+std::string HybridCert::exportCertPem() {
+  this->beginCall();
+  return exportCertPem_impl();
+}
+std::string HybridCert::exportCertPem_impl() {
+  CkString _out;
+  if (!this->ck().ExportCertPem(_out)) throw this->fail("exportCertPem");
+  return rt::stdString(_out);
+}
+
+void HybridCert::exportCertPemFile(const std::string& path) {
+  this->beginCall();
+  exportCertPemFile_impl(path);
+}
+void HybridCert::exportCertPemFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().ExportCertPemFile(path.c_str())) throw this->fail("exportCertPemFile");
+}
+
+std::string HybridCert::exportCertXml() {
+  this->beginCall();
+  return exportCertXml_impl();
+}
+std::string HybridCert::exportCertXml_impl() {
+  CkString _out;
+  if (!this->ck().ExportCertXml(_out)) throw this->fail("exportCertXml");
+  return rt::stdString(_out);
+}
+
+void HybridCert::exportToPfxFile(const std::string& pfxFilename, const std::string& pfxPassword, bool bIncludeCertChain) {
+  this->beginCall();
+  exportToPfxFile_impl(pfxFilename, pfxPassword, bIncludeCertChain);
+}
+void HybridCert::exportToPfxFile_impl(const std::string& pfxFilename, const std::string& pfxPassword, bool bIncludeCertChain) {
+  rt::checkNoNul(pfxFilename, "pfxFilename");
+  rt::checkNoNul(pfxPassword, "pfxPassword");
+  if (!this->ck().ExportToPfxFile(pfxFilename.c_str(), pfxPassword.c_str(), bIncludeCertChain)) throw this->fail("exportToPfxFile");
+}
+
+std::shared_ptr<HybridCertSpec> HybridCert::findIssuer() {
+  this->beginCall();
+  return findIssuer_impl();
+}
+std::shared_ptr<HybridCertSpec> HybridCert::findIssuer_impl() {
+  CkCert* _r = this->ck().FindIssuer();
+  if (!_r) throw this->fail("findIssuer");
+  return std::make_shared<HybridCert>(_r);
+}
+
+std::string HybridCert::getEncoded() {
+  this->beginCall();
+  return getEncoded_impl();
+}
+std::string HybridCert::getEncoded_impl() {
+  CkString _out;
+  if (!this->ck().GetEncoded(_out)) throw this->fail("getEncoded");
+  return rt::stdString(_out);
+}
+
+std::string HybridCert::getExtensionAsXml(const std::string& oid) {
+  this->beginCall();
+  return getExtensionAsXml_impl(oid);
+}
+std::string HybridCert::getExtensionAsXml_impl(const std::string& oid) {
+  rt::checkNoNul(oid, "oid");
+  CkString _out;
+  if (!this->ck().GetExtensionAsXml(oid.c_str(), _out)) throw this->fail("getExtensionAsXml");
+  return rt::stdString(_out);
+}
+
+std::string HybridCert::getPrivateKeyPem() {
+  this->beginCall();
+  return getPrivateKeyPem_impl();
+}
+std::string HybridCert::getPrivateKeyPem_impl() {
+  CkString _out;
+  if (!this->ck().GetPrivateKeyPem(_out)) throw this->fail("getPrivateKeyPem");
+  return rt::stdString(_out);
+}
+
+std::string HybridCert::getSpkiFingerprint(const std::string& hashAlg, const std::string& encoding) {
+  this->beginCall();
+  return getSpkiFingerprint_impl(hashAlg, encoding);
+}
+std::string HybridCert::getSpkiFingerprint_impl(const std::string& hashAlg, const std::string& encoding) {
+  rt::checkNoNul(hashAlg, "hashAlg");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetSpkiFingerprint(hashAlg.c_str(), encoding.c_str(), _out)) throw this->fail("getSpkiFingerprint");
+  return rt::stdString(_out);
+}
+
+bool HybridCert::hasPrivateKey() {
+  this->beginCall();
+  return hasPrivateKey_impl();
+}
+bool HybridCert::hasPrivateKey_impl() {
+  return this->ck().HasPrivateKey();
+}
+
+void HybridCert::loadByCommonName(const std::string& cn) {
+  this->beginCall();
+  loadByCommonName_impl(cn);
+}
+void HybridCert::loadByCommonName_impl(const std::string& cn) {
+  rt::checkNoNul(cn, "cn");
+  if (!this->ck().LoadByCommonName(cn.c_str())) throw this->fail("loadByCommonName");
+}
+
+void HybridCert::loadByEmailAddress(const std::string& emailAddress) {
+  this->beginCall();
+  loadByEmailAddress_impl(emailAddress);
+}
+void HybridCert::loadByEmailAddress_impl(const std::string& emailAddress) {
+  rt::checkNoNul(emailAddress, "emailAddress");
+  if (!this->ck().LoadByEmailAddress(emailAddress.c_str())) throw this->fail("loadByEmailAddress");
+}
+
+void HybridCert::loadByIssuerAndSerialNumber(const std::string& issuerCN, const std::string& serialNumber) {
+  this->beginCall();
+  loadByIssuerAndSerialNumber_impl(issuerCN, serialNumber);
+}
+void HybridCert::loadByIssuerAndSerialNumber_impl(const std::string& issuerCN, const std::string& serialNumber) {
+  rt::checkNoNul(issuerCN, "issuerCN");
+  rt::checkNoNul(serialNumber, "serialNumber");
+  if (!this->ck().LoadByIssuerAndSerialNumber(issuerCN.c_str(), serialNumber.c_str())) throw this->fail("loadByIssuerAndSerialNumber");
+}
+
+void HybridCert::loadFromBase64(const std::string& encodedCert) {
+  this->beginCall();
+  loadFromBase64_impl(encodedCert);
+}
+void HybridCert::loadFromBase64_impl(const std::string& encodedCert) {
+  rt::checkNoNul(encodedCert, "encodedCert");
+  if (!this->ck().LoadFromBase64(encodedCert.c_str())) throw this->fail("loadFromBase64");
+}
+
+void HybridCert::loadFromFile(const std::string& path) {
+  this->beginCall();
+  loadFromFile_impl(path);
+}
+void HybridCert::loadFromFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().LoadFromFile(path.c_str())) throw this->fail("loadFromFile");
+}
+
+void HybridCert::loadPem(const std::string& strPem) {
+  this->beginCall();
+  loadPem_impl(strPem);
+}
+void HybridCert::loadPem_impl(const std::string& strPem) {
+  rt::checkNoNul(strPem, "strPem");
+  if (!this->ck().LoadPem(strPem.c_str())) throw this->fail("loadPem");
+}
+
+void HybridCert::loadPfxFile(const std::string& pfxPath, const std::string& password) {
+  this->beginCall();
+  loadPfxFile_impl(pfxPath, password);
+}
+void HybridCert::loadPfxFile_impl(const std::string& pfxPath, const std::string& password) {
+  rt::checkNoNul(pfxPath, "pfxPath");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadPfxFile(pfxPath.c_str(), password.c_str())) throw this->fail("loadPfxFile");
+}
+
+void HybridCert::pemFileToDerFile(const std::string& fromPath, const std::string& toPath) {
+  this->beginCall();
+  pemFileToDerFile_impl(fromPath, toPath);
+}
+void HybridCert::pemFileToDerFile_impl(const std::string& fromPath, const std::string& toPath) {
+  rt::checkNoNul(fromPath, "fromPath");
+  rt::checkNoNul(toPath, "toPath");
+  if (!this->ck().PemFileToDerFile(fromPath.c_str(), toPath.c_str())) throw this->fail("pemFileToDerFile");
+}
+
+void HybridCert::saveToFile(const std::string& path) {
+  this->beginCall();
+  saveToFile_impl(path);
+}
+void HybridCert::saveToFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SaveToFile(path.c_str())) throw this->fail("saveToFile");
+}
+
+void HybridCert::setFromEncoded(const std::string& encodedCert) {
+  this->beginCall();
+  setFromEncoded_impl(encodedCert);
+}
+void HybridCert::setFromEncoded_impl(const std::string& encodedCert) {
+  rt::checkNoNul(encodedCert, "encodedCert");
+  if (!this->ck().SetFromEncoded(encodedCert.c_str())) throw this->fail("setFromEncoded");
+}
+
+void HybridCert::setPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  setPrivateKey_impl(privKey);
+}
+void HybridCert::setPrivateKey_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  if (!this->ck().SetPrivateKey(rt::implOf<HybridPrivateKey>(privKey, "privKey").ck())) throw this->fail("setPrivateKey");
+}
+
+void HybridCert::setPrivateKeyPem(const std::string& privKeyPem) {
+  this->beginCall();
+  setPrivateKeyPem_impl(privKeyPem);
+}
+void HybridCert::setPrivateKeyPem_impl(const std::string& privKeyPem) {
+  rt::checkNoNul(privKeyPem, "privKeyPem");
+  if (!this->ck().SetPrivateKeyPem(privKeyPem.c_str())) throw this->fail("setPrivateKeyPem");
+}
+
+void HybridCert::useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  this->beginCall();
+  useCertVault_impl(vault);
+}
+void HybridCert::useCertVault_impl(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  if (!this->ck().UseCertVault(rt::implOf<HybridXmlCertVault>(vault, "vault").ck())) throw this->fail("useCertVault");
+}
+
+bool HybridCert::verifySignature() {
+  this->beginCall();
+  return verifySignature_impl();
+}
+bool HybridCert::verifySignature_impl() {
+  return this->ck().VerifySignature();
+}
+
+void HybridCert::exportToPfxBd(const std::string& password, bool includeCertChain, const std::shared_ptr<HybridBinDataSpec>& pfxData) {
+  this->beginCall();
+  exportToPfxBd_impl(password, includeCertChain, pfxData);
+}
+void HybridCert::exportToPfxBd_impl(const std::string& password, bool includeCertChain, const std::shared_ptr<HybridBinDataSpec>& pfxData) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().ExportToPfxBd(password.c_str(), includeCertChain, rt::implOf<HybridBinData>(pfxData, "pfxData").ck())) throw this->fail("exportToPfxBd");
+}
+
+void HybridCert::exportCertDerBd(const std::shared_ptr<HybridBinDataSpec>& cerData) {
+  this->beginCall();
+  exportCertDerBd_impl(cerData);
+}
+void HybridCert::exportCertDerBd_impl(const std::shared_ptr<HybridBinDataSpec>& cerData) {
+  if (!this->ck().ExportCertDerBd(rt::implOf<HybridBinData>(cerData, "cerData").ck())) throw this->fail("exportCertDerBd");
+}
+
+void HybridCert::loadPfxBd(const std::shared_ptr<HybridBinDataSpec>& pfxData, const std::string& password) {
+  this->beginCall();
+  loadPfxBd_impl(pfxData, password);
+}
+void HybridCert::loadPfxBd_impl(const std::shared_ptr<HybridBinDataSpec>& pfxData, const std::string& password) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadPfxBd(rt::implOf<HybridBinData>(pfxData, "pfxData").ck(), password.c_str())) throw this->fail("loadPfxBd");
+}
+
+void HybridCert::loadFromBd(const std::shared_ptr<HybridBinDataSpec>& certBytes) {
+  this->beginCall();
+  loadFromBd_impl(certBytes);
+}
+void HybridCert::loadFromBd_impl(const std::shared_ptr<HybridBinDataSpec>& certBytes) {
+  if (!this->ck().LoadFromBd(rt::implOf<HybridBinData>(certBytes, "certBytes").ck())) throw this->fail("loadFromBd");
+}
+
+std::string HybridCert::hashOf(const std::string& part, const std::string& hashAlg, const std::string& encoding) {
+  this->beginCall();
+  return hashOf_impl(part, hashAlg, encoding);
+}
+std::string HybridCert::hashOf_impl(const std::string& part, const std::string& hashAlg, const std::string& encoding) {
+  rt::checkNoNul(part, "part");
+  rt::checkNoNul(hashAlg, "hashAlg");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().HashOf(part.c_str(), hashAlg.c_str(), encoding.c_str(), _out)) throw this->fail("hashOf");
+  return rt::stdString(_out);
+}
+
+double HybridCert::checkSmartCardPin() {
+  this->beginCall();
+  return checkSmartCardPin_impl();
+}
+double HybridCert::checkSmartCardPin_impl() {
+  return static_cast<double>(this->ck().CheckSmartCardPin());
+}
+
+std::string HybridCert::x509PKIPathv1() {
+  this->beginCall();
+  return x509PKIPathv1_impl();
+}
+std::string HybridCert::x509PKIPathv1_impl() {
+  CkString _out;
+  if (!this->ck().X509PKIPathv1(_out)) throw this->fail("x509PKIPathv1");
+  return rt::stdString(_out);
+}
+
+void HybridCert::loadFromSmartcard(const std::string& certSpec) {
+  this->beginCall();
+  loadFromSmartcard_impl(certSpec);
+}
+void HybridCert::loadFromSmartcard_impl(const std::string& certSpec) {
+  rt::checkNoNul(certSpec, "certSpec");
+  if (!this->ck().LoadFromSmartcard(certSpec.c_str())) throw this->fail("loadFromSmartcard");
+}
+
+void HybridCert::loadByThumbprint(const std::string& thumbprint, const std::string& encoding) {
+  this->beginCall();
+  loadByThumbprint_impl(thumbprint, encoding);
+}
+void HybridCert::loadByThumbprint_impl(const std::string& thumbprint, const std::string& encoding) {
+  rt::checkNoNul(thumbprint, "thumbprint");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().LoadByThumbprint(thumbprint.c_str(), encoding.c_str())) throw this->fail("loadByThumbprint");
+}
+
+void HybridCert::loadBySubjectOid(const std::string& oid, const std::string& value) {
+  this->beginCall();
+  loadBySubjectOid_impl(oid, value);
+}
+void HybridCert::loadBySubjectOid_impl(const std::string& oid, const std::string& value) {
+  rt::checkNoNul(oid, "oid");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().LoadBySubjectOid(oid.c_str(), value.c_str())) throw this->fail("loadBySubjectOid");
+}
+
+std::string HybridCert::getSubjectPart(const std::string& partNameOrOid) {
+  this->beginCall();
+  return getSubjectPart_impl(partNameOrOid);
+}
+std::string HybridCert::getSubjectPart_impl(const std::string& partNameOrOid) {
+  rt::checkNoNul(partNameOrOid, "partNameOrOid");
+  CkString _out;
+  if (!this->ck().GetSubjectPart(partNameOrOid.c_str(), _out)) throw this->fail("getSubjectPart");
+  return rt::stdString(_out);
+}
+
+std::string HybridCert::getExtensionAsText(const std::string& oid) {
+  this->beginCall();
+  return getExtensionAsText_impl(oid);
+}
+std::string HybridCert::getExtensionAsText_impl(const std::string& oid) {
+  rt::checkNoNul(oid, "oid");
+  CkString _out;
+  if (!this->ck().GetExtensionAsText(oid.c_str(), _out)) throw this->fail("getExtensionAsText");
+  return rt::stdString(_out);
+}
+
+void HybridCert::getPubKeyDer(bool preferPkcs1, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  getPubKeyDer_impl(preferPkcs1, bd);
+}
+void HybridCert::getPubKeyDer_impl(bool preferPkcs1, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().GetPubKeyDer(preferPkcs1, rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("getPubKeyDer");
+}
+
+void HybridCert::getSignature(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  getSignature_impl(bd);
+}
+void HybridCert::getSignature_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().GetSignature(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("getSignature");
+}
+
+void HybridCert::getExtensionBd(const std::string& oid, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  getExtensionBd_impl(oid, bd);
+}
+void HybridCert::getExtensionBd_impl(const std::string& oid, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(oid, "oid");
+  if (!this->ck().GetExtensionBd(oid.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("getExtensionBd");
+}
+
+void HybridCert::linkPkcs11(const std::shared_ptr<HybridPkcs11Spec>& session) {
+  this->beginCall();
+  linkPkcs11_impl(session);
+}
+void HybridCert::linkPkcs11_impl(const std::shared_ptr<HybridPkcs11Spec>& session) {
+  if (!this->ck().LinkPkcs11(rt::implOf<HybridPkcs11>(session, "session").ck())) throw this->fail("linkPkcs11");
+}
+
+void HybridCert::uploadToCloud(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) {
+  this->beginCall();
+  uploadToCloud_impl(jsonIn, jsonOut);
+}
+void HybridCert::uploadToCloud_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) {
+  if (!this->ck().UploadToCloud(rt::implOf<HybridJsonObject>(jsonIn, "jsonIn").ck(), rt::implOf<HybridJsonObject>(jsonOut, "jsonOut").ck())) throw this->fail("uploadToCloud");
+}
+std::shared_ptr<Promise<void>> HybridCert::uploadToCloudAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCert>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(jsonIn);
+  _parts.push_back(jsonOut);
+  return rt::runAsync<void>("Cert.uploadToCloudAsync", std::move(_parts), [_self, jsonIn, jsonOut]() {
+    _self->uploadToCloud_impl(jsonIn, jsonOut);
+  });
+}
+
+void HybridCert::setCloudSigner(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  setCloudSigner_impl(json);
+}
+void HybridCert::setCloudSigner_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().SetCloudSigner(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("setCloudSigner");
+}
+std::shared_ptr<Promise<void>> HybridCert::setCloudSignerAsync(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCert>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(json);
+  return rt::runAsync<void>("Cert.setCloudSignerAsync", std::move(_parts), [_self, json]() {
+    _self->setCloudSigner_impl(json);
+  });
+}
+
+bool HybridCert::isRsa() {
+  this->beginCall();
+  return isRsa_impl();
+}
+bool HybridCert::isRsa_impl() {
+  return this->ck().IsRsa();
+}
+
+bool HybridCert::isEcdsa() {
+  this->beginCall();
+  return isEcdsa_impl();
+}
+bool HybridCert::isEcdsa_impl() {
+  return this->ck().IsEcdsa();
+}
+
+void HybridCert::unload() {
+  this->beginCall();
+  unload_impl();
+}
+void HybridCert::unload_impl() {
+  if (!this->ck().Unload()) throw this->fail("unload");
+}
+
+void HybridCert::getPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  getPrivateKey_impl(privKey);
+}
+void HybridCert::getPrivateKey_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  if (!this->ck().GetPrivateKey(rt::implOf<HybridPrivateKey>(privKey, "privKey").ck())) throw this->fail("getPrivateKey");
+}
+
+void HybridCert::getPublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubKey) {
+  this->beginCall();
+  getPublicKey_impl(pubKey);
+}
+void HybridCert::getPublicKey_impl(const std::shared_ptr<HybridPublicKeySpec>& pubKey) {
+  if (!this->ck().GetPublicKey(rt::implOf<HybridPublicKey>(pubKey, "pubKey").ck())) throw this->fail("getPublicKey");
+}
+
+void HybridCert::getIssuer(const std::shared_ptr<HybridCertSpec>& issuer) {
+  this->beginCall();
+  getIssuer_impl(issuer);
+}
+void HybridCert::getIssuer_impl(const std::shared_ptr<HybridCertSpec>& issuer) {
+  if (!this->ck().GetIssuer(rt::implOf<HybridCert>(issuer, "issuer").ck())) throw this->fail("getIssuer");
+}
+
+void HybridCert::buildCertChain(const std::shared_ptr<HybridCertChainSpec>& certChain) {
+  this->beginCall();
+  buildCertChain_impl(certChain);
+}
+void HybridCert::buildCertChain_impl(const std::shared_ptr<HybridCertChainSpec>& certChain) {
+  if (!this->ck().BuildCertChain(rt::implOf<HybridCertChain>(certChain, "certChain").ck())) throw this->fail("buildCertChain");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridCert::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridCert::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridCert::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridCert::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridCert::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat