@chilkat/react-native 11.6.1

package/cpp/HybridCert.hpp

@@ -0,0 +1,196 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Cert: the Nitro HybridObject over Chilkat's CkCert (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridCertSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkCert.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridCert final : public HybridCertSpec, public ChilkatObject<CkCert> {
+public:
+  HybridCert();                                  // `new Cert()` from JS
+  explicit HybridCert(CkCert* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  std::string getAuthorityKeyId() override;
+  bool getAvoidWindowsPkAccess() override;
+  void setAvoidWindowsPkAccess(bool value) override;
+  double getCertVersion() override;
+  bool getExpired() override;
+  bool getForClientAuthentication() override;
+  bool getForCodeSigning() override;
+  bool getForSecureEmail() override;
+  bool getForServerAuthentication() override;
+  bool getForTimeStamping() override;
+  double getIntendedKeyUsage() override;
+  bool getIsRoot() override;
+  std::string getIssuerC() override;
+  std::string getIssuerCN() override;
+  std::string getIssuerDN() override;
+  std::string getIssuerE() override;
+  std::string getIssuerL() override;
+  std::string getIssuerO() override;
+  std::string getIssuerOU() override;
+  std::string getIssuerS() override;
+  std::string getOcspUrl() override;
+  bool getPrivateKeyExportable() override;
+  bool getRevoked() override;
+  std::string getRfc822Name() override;
+  bool getSelfSigned() override;
+  std::string getSerialNumber() override;
+  std::string getSha1Thumbprint() override;
+  bool getSignatureVerified() override;
+  std::string getSubjectC() override;
+  std::string getSubjectCN() override;
+  std::string getSubjectDN() override;
+  std::string getSubjectE() override;
+  std::string getSubjectKeyId() override;
+  std::string getSubjectL() override;
+  std::string getSubjectO() override;
+  std::string getSubjectOU() override;
+  std::string getSubjectS() override;
+  bool getTrustedRoot() override;
+  std::string getValidFromStr() override;
+  std::string getValidToStr() override;
+  std::string getSerialDecimal() override;
+  std::string getSmartCardPin() override;
+  void setSmartCardPin(const std::string& value) override;
+  bool getSmartCardNoDialog() override;
+  void setSmartCardNoDialog(bool value) override;
+  std::string getExtendedKeyUsage() override;
+  std::string getSubjectAlternativeName() override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+  double getSmartCardFailReason() override;
+
+  // ---- Methods ----
+  double checkRevoked() override;
+  void exportCertDerFile(const std::string& path) override;
+  std::string exportCertPem() override;
+  void exportCertPemFile(const std::string& path) override;
+  std::string exportCertXml() override;
+  void exportToPfxFile(const std::string& pfxFilename, const std::string& pfxPassword, bool bIncludeCertChain) override;
+  std::shared_ptr<HybridCertSpec> findIssuer() override;
+  std::string getEncoded() override;
+  std::string getExtensionAsXml(const std::string& oid) override;
+  std::string getPrivateKeyPem() override;
+  std::string getSpkiFingerprint(const std::string& hashAlg, const std::string& encoding) override;
+  bool hasPrivateKey() override;
+  void loadByCommonName(const std::string& cn) override;
+  void loadByEmailAddress(const std::string& emailAddress) override;
+  void loadByIssuerAndSerialNumber(const std::string& issuerCN, const std::string& serialNumber) override;
+  void loadFromBase64(const std::string& encodedCert) override;
+  void loadFromFile(const std::string& path) override;
+  void loadPem(const std::string& strPem) override;
+  void loadPfxFile(const std::string& pfxPath, const std::string& password) override;
+  void pemFileToDerFile(const std::string& fromPath, const std::string& toPath) override;
+  void saveToFile(const std::string& path) override;
+  void setFromEncoded(const std::string& encodedCert) override;
+  void setPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) override;
+  void setPrivateKeyPem(const std::string& privKeyPem) override;
+  void useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) override;
+  bool verifySignature() override;
+  void exportToPfxBd(const std::string& password, bool includeCertChain, const std::shared_ptr<HybridBinDataSpec>& pfxData) override;
+  void exportCertDerBd(const std::shared_ptr<HybridBinDataSpec>& cerData) override;
+  void loadPfxBd(const std::shared_ptr<HybridBinDataSpec>& pfxData, const std::string& password) override;
+  void loadFromBd(const std::shared_ptr<HybridBinDataSpec>& certBytes) override;
+  std::string hashOf(const std::string& part, const std::string& hashAlg, const std::string& encoding) override;
+  double checkSmartCardPin() override;
+  std::string x509PKIPathv1() override;
+  void loadFromSmartcard(const std::string& certSpec) override;
+  void loadByThumbprint(const std::string& thumbprint, const std::string& encoding) override;
+  void loadBySubjectOid(const std::string& oid, const std::string& value) override;
+  std::string getSubjectPart(const std::string& partNameOrOid) override;
+  std::string getExtensionAsText(const std::string& oid) override;
+  void getPubKeyDer(bool preferPkcs1, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void getSignature(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void getExtensionBd(const std::string& oid, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void linkPkcs11(const std::shared_ptr<HybridPkcs11Spec>& session) override;
+  void uploadToCloud(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  std::shared_ptr<Promise<void>> uploadToCloudAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  void setCloudSigner(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  std::shared_ptr<Promise<void>> setCloudSignerAsync(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  bool isRsa() override;
+  bool isEcdsa() override;
+  void unload() override;
+  void getPrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) override;
+  void getPublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubKey) override;
+  void getIssuer(const std::shared_ptr<HybridCertSpec>& issuer) override;
+  void buildCertChain(const std::shared_ptr<HybridCertChainSpec>& certChain) override;
+
+  // ---- Events (ReactNativeGen_DESIGN.md §6) ----
+  std::optional<std::function<void(double)>> getOnPercentDone() override;
+  void setOnPercentDone(const std::optional<std::function<void(double)>>& cb) override;
+  std::optional<std::function<void(const std::string&, const std::string&)>> getOnProgressInfo() override;
+  void setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) override;
+  void abort() override;
+
+private:
+  void init();
+  double checkRevoked_impl();
+  void exportCertDerFile_impl(const std::string& path);
+  std::string exportCertPem_impl();
+  void exportCertPemFile_impl(const std::string& path);
+  std::string exportCertXml_impl();
+  void exportToPfxFile_impl(const std::string& pfxFilename, const std::string& pfxPassword, bool bIncludeCertChain);
+  std::shared_ptr<HybridCertSpec> findIssuer_impl();
+  std::string getEncoded_impl();
+  std::string getExtensionAsXml_impl(const std::string& oid);
+  std::string getPrivateKeyPem_impl();
+  std::string getSpkiFingerprint_impl(const std::string& hashAlg, const std::string& encoding);
+  bool hasPrivateKey_impl();
+  void loadByCommonName_impl(const std::string& cn);
+  void loadByEmailAddress_impl(const std::string& emailAddress);
+  void loadByIssuerAndSerialNumber_impl(const std::string& issuerCN, const std::string& serialNumber);
+  void loadFromBase64_impl(const std::string& encodedCert);
+  void loadFromFile_impl(const std::string& path);
+  void loadPem_impl(const std::string& strPem);
+  void loadPfxFile_impl(const std::string& pfxPath, const std::string& password);
+  void pemFileToDerFile_impl(const std::string& fromPath, const std::string& toPath);
+  void saveToFile_impl(const std::string& path);
+  void setFromEncoded_impl(const std::string& encodedCert);
+  void setPrivateKey_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey);
+  void setPrivateKeyPem_impl(const std::string& privKeyPem);
+  void useCertVault_impl(const std::shared_ptr<HybridXmlCertVaultSpec>& vault);
+  bool verifySignature_impl();
+  void exportToPfxBd_impl(const std::string& password, bool includeCertChain, const std::shared_ptr<HybridBinDataSpec>& pfxData);
+  void exportCertDerBd_impl(const std::shared_ptr<HybridBinDataSpec>& cerData);
+  void loadPfxBd_impl(const std::shared_ptr<HybridBinDataSpec>& pfxData, const std::string& password);
+  void loadFromBd_impl(const std::shared_ptr<HybridBinDataSpec>& certBytes);
+  std::string hashOf_impl(const std::string& part, const std::string& hashAlg, const std::string& encoding);
+  double checkSmartCardPin_impl();
+  std::string x509PKIPathv1_impl();
+  void loadFromSmartcard_impl(const std::string& certSpec);
+  void loadByThumbprint_impl(const std::string& thumbprint, const std::string& encoding);
+  void loadBySubjectOid_impl(const std::string& oid, const std::string& value);
+  std::string getSubjectPart_impl(const std::string& partNameOrOid);
+  std::string getExtensionAsText_impl(const std::string& oid);
+  void getPubKeyDer_impl(bool preferPkcs1, const std::shared_ptr<HybridBinDataSpec>& bd);
+  void getSignature_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  void getExtensionBd_impl(const std::string& oid, const std::shared_ptr<HybridBinDataSpec>& bd);
+  void linkPkcs11_impl(const std::shared_ptr<HybridPkcs11Spec>& session);
+  void uploadToCloud_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut);
+  void setCloudSigner_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  bool isRsa_impl();
+  bool isEcdsa_impl();
+  void unload_impl();
+  void getPrivateKey_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey);
+  void getPublicKey_impl(const std::shared_ptr<HybridPublicKeySpec>& pubKey);
+  void getIssuer_impl(const std::shared_ptr<HybridCertSpec>& issuer);
+  void buildCertChain_impl(const std::shared_ptr<HybridCertChainSpec>& certChain);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridCertChain.cpp

@@ -0,0 +1,149 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridCertChain.hpp"
+#include "HybridCert.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridTrustedRoots.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridCertChain::HybridCertChain()
+    : HybridObject(HybridCertChainSpec::TAG), ChilkatObject<CkCertChain>("CertChain", CkCertChain::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridCertChain::HybridCertChain(CkCertChain* owned)
+    : HybridObject(HybridCertChainSpec::TAG), ChilkatObject<CkCertChain>("CertChain", owned) {
+  init();
+}
+
+void HybridCertChain::init() {
+}
+
+void HybridCertChain::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridCertChain::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCertChain::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCertChain::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCertChain::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCertChain::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridCertChain::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridCertChain::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridCertChain::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridCertChain::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridCertChain::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridCertChain::getNumCerts() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumCerts());
+}
+double HybridCertChain::getNumExpiredCerts() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumExpiredCerts());
+}
+bool HybridCertChain::getReachesRoot() {
+  this->beginCall();
+  return this->ck().get_ReachesRoot();
+}
+std::string HybridCertChain::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridCertChain::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+bool HybridCertChain::isRootTrusted(const std::shared_ptr<HybridTrustedRootsSpec>& trustedRoots) {
+  this->beginCall();
+  return isRootTrusted_impl(trustedRoots);
+}
+bool HybridCertChain::isRootTrusted_impl(const std::shared_ptr<HybridTrustedRootsSpec>& trustedRoots) {
+  return this->ck().IsRootTrusted(rt::implOf<HybridTrustedRoots>(trustedRoots, "trustedRoots").ck());
+}
+
+bool HybridCertChain::verifyCertSignatures() {
+  this->beginCall();
+  return verifyCertSignatures_impl();
+}
+bool HybridCertChain::verifyCertSignatures_impl() {
+  return this->ck().VerifyCertSignatures();
+}
+
+void HybridCertChain::loadX5C(const std::shared_ptr<HybridJsonObjectSpec>& jwk) {
+  this->beginCall();
+  loadX5C_impl(jwk);
+}
+void HybridCertChain::loadX5C_impl(const std::shared_ptr<HybridJsonObjectSpec>& jwk) {
+  if (!this->ck().LoadX5C(rt::implOf<HybridJsonObject>(jwk, "jwk").ck())) throw this->fail("loadX5C");
+}
+
+std::string HybridCertChain::x509PKIPathv1() {
+  this->beginCall();
+  return x509PKIPathv1_impl();
+}
+std::string HybridCertChain::x509PKIPathv1_impl() {
+  CkString _out;
+  if (!this->ck().X509PKIPathv1(_out)) throw this->fail("x509PKIPathv1");
+  return rt::stdString(_out);
+}
+
+void HybridCertChain::certAt(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  certAt_impl(index, cert);
+}
+void HybridCertChain::certAt_impl(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().CertAt(rt::toInt(index, "index"), rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("certAt");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridCertChain.hpp

@@ -0,0 +1,50 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// CertChain: the Nitro HybridObject over Chilkat's CkCertChain (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridCertChainSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkCertChain.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridCertChain final : public HybridCertChainSpec, public ChilkatObject<CkCertChain> {
+public:
+  HybridCertChain();                                  // `new CertChain()` from JS
+  explicit HybridCertChain(CkCertChain* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  double getNumCerts() override;
+  double getNumExpiredCerts() override;
+  bool getReachesRoot() override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+
+  // ---- Methods ----
+  bool isRootTrusted(const std::shared_ptr<HybridTrustedRootsSpec>& trustedRoots) override;
+  bool verifyCertSignatures() override;
+  void loadX5C(const std::shared_ptr<HybridJsonObjectSpec>& jwk) override;
+  std::string x509PKIPathv1() override;
+  void certAt(double index, const std::shared_ptr<HybridCertSpec>& cert) override;
+
+private:
+  void init();
+  bool isRootTrusted_impl(const std::shared_ptr<HybridTrustedRootsSpec>& trustedRoots);
+  bool verifyCertSignatures_impl();
+  void loadX5C_impl(const std::shared_ptr<HybridJsonObjectSpec>& jwk);
+  std::string x509PKIPathv1_impl();
+  void certAt_impl(double index, const std::shared_ptr<HybridCertSpec>& cert);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridCertStore.cpp

@@ -0,0 +1,276 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridCertStore.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCert.hpp"
+#include "HybridJsonObject.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridCertStore::HybridCertStore()
+    : HybridObject(HybridCertStoreSpec::TAG), ChilkatObject<CkCertStore>("CertStore", CkCertStore::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridCertStore::HybridCertStore(CkCertStore* owned)
+    : HybridObject(HybridCertStoreSpec::TAG), ChilkatObject<CkCertStore>("CertStore", owned) {
+  init();
+}
+
+void HybridCertStore::init() {
+}
+
+void HybridCertStore::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridCertStore::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCertStore::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCertStore::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCertStore::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCertStore::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridCertStore::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridCertStore::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridCertStore::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridCertStore::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridCertStore::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridCertStore::getAvoidWindowsPkAccess() {
+  this->beginCall();
+  return this->ck().get_AvoidWindowsPkAccess();
+}
+void HybridCertStore::setAvoidWindowsPkAccess(bool value) {
+  this->beginCall();
+  this->ck().put_AvoidWindowsPkAccess(value);
+}
+double HybridCertStore::getNumCertificates() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumCertificates());
+}
+std::string HybridCertStore::getSmartCardPin() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SmartCardPin(_s);
+  return rt::stdString(_s);
+}
+void HybridCertStore::setSmartCardPin(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "smartCardPin");
+  this->ck().put_SmartCardPin(value.c_str());
+}
+std::string HybridCertStore::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridCertStore::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridCertStore::addCertificate(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  addCertificate_impl(cert);
+}
+void HybridCertStore::addCertificate_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().AddCertificate(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("addCertificate");
+}
+
+void HybridCertStore::createFileStore(const std::string& filename) {
+  this->beginCall();
+  createFileStore_impl(filename);
+}
+void HybridCertStore::createFileStore_impl(const std::string& filename) {
+  rt::checkNoNul(filename, "filename");
+  if (!this->ck().CreateFileStore(filename.c_str())) throw this->fail("createFileStore");
+}
+
+void HybridCertStore::createMemoryStore() {
+  this->beginCall();
+  createMemoryStore_impl();
+}
+void HybridCertStore::createMemoryStore_impl() {
+  if (!this->ck().CreateMemoryStore()) throw this->fail("createMemoryStore");
+}
+
+void HybridCertStore::createRegistryStore(const std::string& regRoot, const std::string& regPath) {
+  this->beginCall();
+  createRegistryStore_impl(regRoot, regPath);
+}
+void HybridCertStore::createRegistryStore_impl(const std::string& regRoot, const std::string& regPath) {
+  rt::checkNoNul(regRoot, "regRoot");
+  rt::checkNoNul(regPath, "regPath");
+  if (!this->ck().CreateRegistryStore(regRoot.c_str(), regPath.c_str())) throw this->fail("createRegistryStore");
+}
+
+void HybridCertStore::loadPemFile(const std::string& pemPath) {
+  this->beginCall();
+  loadPemFile_impl(pemPath);
+}
+void HybridCertStore::loadPemFile_impl(const std::string& pemPath) {
+  rt::checkNoNul(pemPath, "pemPath");
+  if (!this->ck().LoadPemFile(pemPath.c_str())) throw this->fail("loadPemFile");
+}
+
+void HybridCertStore::loadPemStr(const std::string& pemString) {
+  this->beginCall();
+  loadPemStr_impl(pemString);
+}
+void HybridCertStore::loadPemStr_impl(const std::string& pemString) {
+  rt::checkNoNul(pemString, "pemString");
+  if (!this->ck().LoadPemStr(pemString.c_str())) throw this->fail("loadPemStr");
+}
+
+void HybridCertStore::loadPfxFile(const std::string& pfxFilename, const std::string& password) {
+  this->beginCall();
+  loadPfxFile_impl(pfxFilename, password);
+}
+void HybridCertStore::loadPfxFile_impl(const std::string& pfxFilename, const std::string& password) {
+  rt::checkNoNul(pfxFilename, "pfxFilename");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadPfxFile(pfxFilename.c_str(), password.c_str())) throw this->fail("loadPfxFile");
+}
+
+void HybridCertStore::openCurrentUserStore(bool bReadOnly) {
+  this->beginCall();
+  openCurrentUserStore_impl(bReadOnly);
+}
+void HybridCertStore::openCurrentUserStore_impl(bool bReadOnly) {
+  if (!this->ck().OpenCurrentUserStore(bReadOnly)) throw this->fail("openCurrentUserStore");
+}
+
+void HybridCertStore::openFileStore(const std::string& filename, bool bReadOnly) {
+  this->beginCall();
+  openFileStore_impl(filename, bReadOnly);
+}
+void HybridCertStore::openFileStore_impl(const std::string& filename, bool bReadOnly) {
+  rt::checkNoNul(filename, "filename");
+  if (!this->ck().OpenFileStore(filename.c_str(), bReadOnly)) throw this->fail("openFileStore");
+}
+
+void HybridCertStore::openLocalSystemStore(bool bReadOnly) {
+  this->beginCall();
+  openLocalSystemStore_impl(bReadOnly);
+}
+void HybridCertStore::openLocalSystemStore_impl(bool bReadOnly) {
+  if (!this->ck().OpenLocalSystemStore(bReadOnly)) throw this->fail("openLocalSystemStore");
+}
+
+void HybridCertStore::openRegistryStore(const std::string& regRoot, const std::string& regPath, bool bReadOnly) {
+  this->beginCall();
+  openRegistryStore_impl(regRoot, regPath, bReadOnly);
+}
+void HybridCertStore::openRegistryStore_impl(const std::string& regRoot, const std::string& regPath, bool bReadOnly) {
+  rt::checkNoNul(regRoot, "regRoot");
+  rt::checkNoNul(regPath, "regPath");
+  if (!this->ck().OpenRegistryStore(regRoot.c_str(), regPath.c_str(), bReadOnly)) throw this->fail("openRegistryStore");
+}
+
+void HybridCertStore::openWindowsStore(const std::string& storeLocation, const std::string& storeName, bool bReadOnly) {
+  this->beginCall();
+  openWindowsStore_impl(storeLocation, storeName, bReadOnly);
+}
+void HybridCertStore::openWindowsStore_impl(const std::string& storeLocation, const std::string& storeName, bool bReadOnly) {
+  rt::checkNoNul(storeLocation, "storeLocation");
+  rt::checkNoNul(storeName, "storeName");
+  if (!this->ck().OpenWindowsStore(storeLocation.c_str(), storeName.c_str(), bReadOnly)) throw this->fail("openWindowsStore");
+}
+
+void HybridCertStore::removeCertificate(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  removeCertificate_impl(cert);
+}
+void HybridCertStore::removeCertificate_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().RemoveCertificate(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("removeCertificate");
+}
+
+void HybridCertStore::openSmartcard(const std::string& csp) {
+  this->beginCall();
+  openSmartcard_impl(csp);
+}
+void HybridCertStore::openSmartcard_impl(const std::string& csp) {
+  rt::checkNoNul(csp, "csp");
+  if (!this->ck().OpenSmartcard(csp.c_str())) throw this->fail("openSmartcard");
+}
+
+void HybridCertStore::closeCertStore() {
+  this->beginCall();
+  closeCertStore_impl();
+}
+void HybridCertStore::closeCertStore_impl() {
+  if (!this->ck().CloseCertStore()) throw this->fail("closeCertStore");
+}
+
+void HybridCertStore::findCert(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  findCert_impl(json, cert);
+}
+void HybridCertStore::findCert_impl(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().FindCert(rt::implOf<HybridJsonObject>(json, "json").ck(), rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("findCert");
+}
+
+void HybridCertStore::loadPfxBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) {
+  this->beginCall();
+  loadPfxBd_impl(bd, password);
+}
+void HybridCertStore::loadPfxBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadPfxBd(rt::implOf<HybridBinData>(bd, "bd").ck(), password.c_str())) throw this->fail("loadPfxBd");
+}
+
+void HybridCertStore::getCert(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  getCert_impl(index, cert);
+}
+void HybridCertStore::getCert_impl(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().GetCert(rt::toInt(index, "index"), rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("getCert");
+}
+
+} // namespace margelo::nitro::chilkat