@chilkat/react-native 11.6.1

package/cpp/HybridSFtpFile.cpp

@@ -0,0 +1,203 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridSFtpFile.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridSFtpFile::HybridSFtpFile()
+    : HybridObject(HybridSFtpFileSpec::TAG), ChilkatObject<CkSFtpFile>("SFtpFile", CkSFtpFile::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridSFtpFile::HybridSFtpFile(CkSFtpFile* owned)
+    : HybridObject(HybridSFtpFileSpec::TAG), ChilkatObject<CkSFtpFile>("SFtpFile", owned) {
+  init();
+}
+
+void HybridSFtpFile::init() {
+}
+
+void HybridSFtpFile::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridSFtpFile::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSFtpFile::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSFtpFile::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSFtpFile::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSFtpFile::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtpFile::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridSFtpFile::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridSFtpFile::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridSFtpFile::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridSFtpFile::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridSFtpFile::getCreateTimeStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CreateTimeStr(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSFtpFile::getFileType() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FileType(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSFtpFile::getFilename() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Filename(_s);
+  return rt::stdString(_s);
+}
+double HybridSFtpFile::getGid() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Gid());
+}
+std::string HybridSFtpFile::getGroup() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Group(_s);
+  return rt::stdString(_s);
+}
+bool HybridSFtpFile::getIsAppendOnly() {
+  this->beginCall();
+  return this->ck().get_IsAppendOnly();
+}
+bool HybridSFtpFile::getIsArchive() {
+  this->beginCall();
+  return this->ck().get_IsArchive();
+}
+bool HybridSFtpFile::getIsCaseInsensitive() {
+  this->beginCall();
+  return this->ck().get_IsCaseInsensitive();
+}
+bool HybridSFtpFile::getIsCompressed() {
+  this->beginCall();
+  return this->ck().get_IsCompressed();
+}
+bool HybridSFtpFile::getIsDirectory() {
+  this->beginCall();
+  return this->ck().get_IsDirectory();
+}
+bool HybridSFtpFile::getIsEncrypted() {
+  this->beginCall();
+  return this->ck().get_IsEncrypted();
+}
+bool HybridSFtpFile::getIsHidden() {
+  this->beginCall();
+  return this->ck().get_IsHidden();
+}
+bool HybridSFtpFile::getIsImmutable() {
+  this->beginCall();
+  return this->ck().get_IsImmutable();
+}
+bool HybridSFtpFile::getIsReadOnly() {
+  this->beginCall();
+  return this->ck().get_IsReadOnly();
+}
+bool HybridSFtpFile::getIsRegular() {
+  this->beginCall();
+  return this->ck().get_IsRegular();
+}
+bool HybridSFtpFile::getIsSparse() {
+  this->beginCall();
+  return this->ck().get_IsSparse();
+}
+bool HybridSFtpFile::getIsSymLink() {
+  this->beginCall();
+  return this->ck().get_IsSymLink();
+}
+bool HybridSFtpFile::getIsSync() {
+  this->beginCall();
+  return this->ck().get_IsSync();
+}
+bool HybridSFtpFile::getIsSystem() {
+  this->beginCall();
+  return this->ck().get_IsSystem();
+}
+std::string HybridSFtpFile::getLastAccessTimeStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastAccessTimeStr(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSFtpFile::getLastModifiedTimeStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastModifiedTimeStr(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSFtpFile::getOwner() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Owner(_s);
+  return rt::stdString(_s);
+}
+double HybridSFtpFile::getPermissions() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Permissions());
+}
+double HybridSFtpFile::getSize32() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Size32());
+}
+double HybridSFtpFile::getSize64() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Size64());
+}
+std::string HybridSFtpFile::getSizeStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SizeStr(_s);
+  return rt::stdString(_s);
+}
+double HybridSFtpFile::getUid() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Uid());
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridSFtpFile.hpp

@@ -0,0 +1,60 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// SFtpFile: the Nitro HybridObject over Chilkat's CkSFtpFile (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridSFtpFileSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkSFtpFile.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridSFtpFile final : public HybridSFtpFileSpec, public ChilkatObject<CkSFtpFile> {
+public:
+  HybridSFtpFile();                                  // `new SFtpFile()` from JS
+  explicit HybridSFtpFile(CkSFtpFile* 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 getCreateTimeStr() override;
+  std::string getFileType() override;
+  std::string getFilename() override;
+  double getGid() override;
+  std::string getGroup() override;
+  bool getIsAppendOnly() override;
+  bool getIsArchive() override;
+  bool getIsCaseInsensitive() override;
+  bool getIsCompressed() override;
+  bool getIsDirectory() override;
+  bool getIsEncrypted() override;
+  bool getIsHidden() override;
+  bool getIsImmutable() override;
+  bool getIsReadOnly() override;
+  bool getIsRegular() override;
+  bool getIsSparse() override;
+  bool getIsSymLink() override;
+  bool getIsSync() override;
+  bool getIsSystem() override;
+  std::string getLastAccessTimeStr() override;
+  std::string getLastModifiedTimeStr() override;
+  std::string getOwner() override;
+  double getPermissions() override;
+  double getSize32() override;
+  double getSize64() override;
+  std::string getSizeStr() override;
+  double getUid() override;
+
+private:
+  void init();
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridScMinidriver.cpp

@@ -0,0 +1,341 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridScMinidriver.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCert.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridPrivateKey.hpp"
+#include "HybridPublicKey.hpp"
+#include "HybridStringTable.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridScMinidriver::HybridScMinidriver()
+    : HybridObject(HybridScMinidriverSpec::TAG), ChilkatObject<CkScMinidriver>("ScMinidriver", CkScMinidriver::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridScMinidriver::HybridScMinidriver(CkScMinidriver* owned)
+    : HybridObject(HybridScMinidriverSpec::TAG), ChilkatObject<CkScMinidriver>("ScMinidriver", owned) {
+  init();
+}
+
+void HybridScMinidriver::init() {
+}
+
+void HybridScMinidriver::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridScMinidriver::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridScMinidriver::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridScMinidriver::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridScMinidriver::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridScMinidriver::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridScMinidriver::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridScMinidriver::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridScMinidriver::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridScMinidriver::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridScMinidriver::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridScMinidriver::getAtr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Atr(_s);
+  return rt::stdString(_s);
+}
+std::string HybridScMinidriver::getCardName() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CardName(_s);
+  return rt::stdString(_s);
+}
+std::string HybridScMinidriver::getRsaPaddingScheme() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_RsaPaddingScheme(_s);
+  return rt::stdString(_s);
+}
+void HybridScMinidriver::setRsaPaddingScheme(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "rsaPaddingScheme");
+  this->ck().put_RsaPaddingScheme(value.c_str());
+}
+std::string HybridScMinidriver::getRsaPaddingHash() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_RsaPaddingHash(_s);
+  return rt::stdString(_s);
+}
+void HybridScMinidriver::setRsaPaddingHash(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "rsaPaddingHash");
+  this->ck().put_RsaPaddingHash(value.c_str());
+}
+double HybridScMinidriver::getMaxContainers() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_MaxContainers());
+}
+std::string HybridScMinidriver::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridScMinidriver::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridScMinidriver::acquireContext(const std::string& readerName) {
+  this->beginCall();
+  acquireContext_impl(readerName);
+}
+void HybridScMinidriver::acquireContext_impl(const std::string& readerName) {
+  rt::checkNoNul(readerName, "readerName");
+  if (!this->ck().AcquireContext(readerName.c_str())) throw this->fail("acquireContext");
+}
+
+void HybridScMinidriver::deleteContext() {
+  this->beginCall();
+  deleteContext_impl();
+}
+void HybridScMinidriver::deleteContext_impl() {
+  if (!this->ck().DeleteContext()) throw this->fail("deleteContext");
+}
+
+void HybridScMinidriver::enumFiles(const std::string& dirName, const std::shared_ptr<HybridStringTableSpec>& st) {
+  this->beginCall();
+  enumFiles_impl(dirName, st);
+}
+void HybridScMinidriver::enumFiles_impl(const std::string& dirName, const std::shared_ptr<HybridStringTableSpec>& st) {
+  rt::checkNoNul(dirName, "dirName");
+  if (!this->ck().EnumFiles(dirName.c_str(), rt::implOf<HybridStringTable>(st, "st").ck())) throw this->fail("enumFiles");
+}
+
+void HybridScMinidriver::readFile(const std::string& dirName, const std::string& fileName, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  readFile_impl(dirName, fileName, bd);
+}
+void HybridScMinidriver::readFile_impl(const std::string& dirName, const std::string& fileName, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(dirName, "dirName");
+  rt::checkNoNul(fileName, "fileName");
+  if (!this->ck().ReadFile(dirName.c_str(), fileName.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("readFile");
+}
+
+void HybridScMinidriver::getCardProperties(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getCardProperties_impl(json);
+}
+void HybridScMinidriver::getCardProperties_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().GetCardProperties(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("getCardProperties");
+}
+
+double HybridScMinidriver::pinAuthenticate(const std::string& pinId, const std::string& pin) {
+  this->beginCall();
+  return pinAuthenticate_impl(pinId, pin);
+}
+double HybridScMinidriver::pinAuthenticate_impl(const std::string& pinId, const std::string& pin) {
+  rt::checkNoNul(pinId, "pinId");
+  rt::checkNoNul(pin, "pin");
+  return static_cast<double>(this->ck().PinAuthenticate(pinId.c_str(), pin.c_str()));
+}
+
+void HybridScMinidriver::pinDeauthenticate(const std::string& pinId) {
+  this->beginCall();
+  pinDeauthenticate_impl(pinId);
+}
+void HybridScMinidriver::pinDeauthenticate_impl(const std::string& pinId) {
+  rt::checkNoNul(pinId, "pinId");
+  if (!this->ck().PinDeauthenticate(pinId.c_str())) throw this->fail("pinDeauthenticate");
+}
+
+double HybridScMinidriver::pinChange(const std::string& pinId, const std::string& currentPin, const std::string& newPin) {
+  this->beginCall();
+  return pinChange_impl(pinId, currentPin, newPin);
+}
+double HybridScMinidriver::pinChange_impl(const std::string& pinId, const std::string& currentPin, const std::string& newPin) {
+  rt::checkNoNul(pinId, "pinId");
+  rt::checkNoNul(currentPin, "currentPin");
+  rt::checkNoNul(newPin, "newPin");
+  return static_cast<double>(this->ck().PinChange(pinId.c_str(), currentPin.c_str(), newPin.c_str()));
+}
+
+void HybridScMinidriver::signData(double containerIndex, const std::string& keySpec, const std::string& hashDataAlg, const std::shared_ptr<HybridBinDataSpec>& bdData, const std::shared_ptr<HybridBinDataSpec>& bdSignedData) {
+  this->beginCall();
+  signData_impl(containerIndex, keySpec, hashDataAlg, bdData, bdSignedData);
+}
+void HybridScMinidriver::signData_impl(double containerIndex, const std::string& keySpec, const std::string& hashDataAlg, const std::shared_ptr<HybridBinDataSpec>& bdData, const std::shared_ptr<HybridBinDataSpec>& bdSignedData) {
+  rt::checkNoNul(keySpec, "keySpec");
+  rt::checkNoNul(hashDataAlg, "hashDataAlg");
+  if (!this->ck().SignData(rt::toInt(containerIndex, "containerIndex"), keySpec.c_str(), hashDataAlg.c_str(), rt::implOf<HybridBinData>(bdData, "bdData").ck(), rt::implOf<HybridBinData>(bdSignedData, "bdSignedData").ck())) throw this->fail("signData");
+}
+
+void HybridScMinidriver::getContainerKeys(double containerIndex, const std::shared_ptr<HybridPublicKeySpec>& sigKey, const std::shared_ptr<HybridPublicKeySpec>& kexKey) {
+  this->beginCall();
+  getContainerKeys_impl(containerIndex, sigKey, kexKey);
+}
+void HybridScMinidriver::getContainerKeys_impl(double containerIndex, const std::shared_ptr<HybridPublicKeySpec>& sigKey, const std::shared_ptr<HybridPublicKeySpec>& kexKey) {
+  if (!this->ck().GetContainerKeys(rt::toInt(containerIndex, "containerIndex"), rt::implOf<HybridPublicKey>(sigKey, "sigKey").ck(), rt::implOf<HybridPublicKey>(kexKey, "kexKey").ck())) throw this->fail("getContainerKeys");
+}
+
+void HybridScMinidriver::generateKey(double containerIndex, const std::string& keySpec, const std::string& keyType, double keySize, const std::string& pinId) {
+  this->beginCall();
+  generateKey_impl(containerIndex, keySpec, keyType, keySize, pinId);
+}
+void HybridScMinidriver::generateKey_impl(double containerIndex, const std::string& keySpec, const std::string& keyType, double keySize, const std::string& pinId) {
+  rt::checkNoNul(keySpec, "keySpec");
+  rt::checkNoNul(keyType, "keyType");
+  rt::checkNoNul(pinId, "pinId");
+  if (!this->ck().GenerateKey(rt::toInt(containerIndex, "containerIndex"), keySpec.c_str(), keyType.c_str(), rt::toInt(keySize, "keySize"), pinId.c_str())) throw this->fail("generateKey");
+}
+
+void HybridScMinidriver::importKey(double containerIndex, const std::string& keySpec, const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::string& pinId) {
+  this->beginCall();
+  importKey_impl(containerIndex, keySpec, privKey, pinId);
+}
+void HybridScMinidriver::importKey_impl(double containerIndex, const std::string& keySpec, const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::string& pinId) {
+  rt::checkNoNul(keySpec, "keySpec");
+  rt::checkNoNul(pinId, "pinId");
+  if (!this->ck().ImportKey(rt::toInt(containerIndex, "containerIndex"), keySpec.c_str(), rt::implOf<HybridPrivateKey>(privKey, "privKey").ck(), pinId.c_str())) throw this->fail("importKey");
+}
+
+void HybridScMinidriver::deleteKeyContainer(double containerIndex) {
+  this->beginCall();
+  deleteKeyContainer_impl(containerIndex);
+}
+void HybridScMinidriver::deleteKeyContainer_impl(double containerIndex) {
+  if (!this->ck().DeleteKeyContainer(rt::toInt(containerIndex, "containerIndex"))) throw this->fail("deleteKeyContainer");
+}
+
+void HybridScMinidriver::getCspContainerMap(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getCspContainerMap_impl(json);
+}
+void HybridScMinidriver::getCspContainerMap_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().GetCspContainerMap(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("getCspContainerMap");
+}
+
+void HybridScMinidriver::listCerts(const std::string& certPart, const std::shared_ptr<HybridStringTableSpec>& st) {
+  this->beginCall();
+  listCerts_impl(certPart, st);
+}
+void HybridScMinidriver::listCerts_impl(const std::string& certPart, const std::shared_ptr<HybridStringTableSpec>& st) {
+  rt::checkNoNul(certPart, "certPart");
+  if (!this->ck().ListCerts(certPart.c_str(), rt::implOf<HybridStringTable>(st, "st").ck())) throw this->fail("listCerts");
+}
+
+void HybridScMinidriver::importCert(const std::shared_ptr<HybridCertSpec>& cert, double containerIndex, const std::string& keySpec, const std::string& pinId) {
+  this->beginCall();
+  importCert_impl(cert, containerIndex, keySpec, pinId);
+}
+void HybridScMinidriver::importCert_impl(const std::shared_ptr<HybridCertSpec>& cert, double containerIndex, const std::string& keySpec, const std::string& pinId) {
+  rt::checkNoNul(keySpec, "keySpec");
+  rt::checkNoNul(pinId, "pinId");
+  if (!this->ck().ImportCert(rt::implOf<HybridCert>(cert, "cert").ck(), rt::toInt(containerIndex, "containerIndex"), keySpec.c_str(), pinId.c_str())) throw this->fail("importCert");
+}
+
+void HybridScMinidriver::writeFile(const std::string& dirName, const std::string& fileName, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  writeFile_impl(dirName, fileName, bd);
+}
+void HybridScMinidriver::writeFile_impl(const std::string& dirName, const std::string& fileName, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(dirName, "dirName");
+  rt::checkNoNul(fileName, "fileName");
+  if (!this->ck().WriteFile(dirName.c_str(), fileName.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("writeFile");
+}
+
+void HybridScMinidriver::getCert(double containerIndex, const std::string& keySpec, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  getCert_impl(containerIndex, keySpec, cert);
+}
+void HybridScMinidriver::getCert_impl(double containerIndex, const std::string& keySpec, const std::shared_ptr<HybridCertSpec>& cert) {
+  rt::checkNoNul(keySpec, "keySpec");
+  if (!this->ck().GetCert(rt::toInt(containerIndex, "containerIndex"), keySpec.c_str(), rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("getCert");
+}
+
+void HybridScMinidriver::findCert(const std::string& certPart, const std::string& partValue, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  findCert_impl(certPart, partValue, cert);
+}
+void HybridScMinidriver::findCert_impl(const std::string& certPart, const std::string& partValue, const std::shared_ptr<HybridCertSpec>& cert) {
+  rt::checkNoNul(certPart, "certPart");
+  rt::checkNoNul(partValue, "partValue");
+  if (!this->ck().FindCert(certPart.c_str(), partValue.c_str(), rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("findCert");
+}
+
+double HybridScMinidriver::pinAuthenticateHex(const std::string& pinId, const std::string& pin) {
+  this->beginCall();
+  return pinAuthenticateHex_impl(pinId, pin);
+}
+double HybridScMinidriver::pinAuthenticateHex_impl(const std::string& pinId, const std::string& pin) {
+  rt::checkNoNul(pinId, "pinId");
+  rt::checkNoNul(pin, "pin");
+  return static_cast<double>(this->ck().PinAuthenticateHex(pinId.c_str(), pin.c_str()));
+}
+
+void HybridScMinidriver::deleteCert(const std::shared_ptr<HybridCertSpec>& cert, bool delPrivKey) {
+  this->beginCall();
+  deleteCert_impl(cert, delPrivKey);
+}
+void HybridScMinidriver::deleteCert_impl(const std::shared_ptr<HybridCertSpec>& cert, bool delPrivKey) {
+  if (!this->ck().DeleteCert(rt::implOf<HybridCert>(cert, "cert").ck(), delPrivKey)) throw this->fail("deleteCert");
+}
+
+void HybridScMinidriver::cardDeleteFile(const std::string& dirName, const std::string& fileName) {
+  this->beginCall();
+  cardDeleteFile_impl(dirName, fileName);
+}
+void HybridScMinidriver::cardDeleteFile_impl(const std::string& dirName, const std::string& fileName) {
+  rt::checkNoNul(dirName, "dirName");
+  rt::checkNoNul(fileName, "fileName");
+  if (!this->ck().CardDeleteFile(dirName.c_str(), fileName.c_str())) throw this->fail("cardDeleteFile");
+}
+
+} // namespace margelo::nitro::chilkat