@chilkat/react-native 11.6.1

package/cpp/HybridMime.cpp

@@ -0,0 +1,1119 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridMime.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCert.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridPrivateKey.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridStringTable.hpp"
+#include "HybridXmlCertVault.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridMime::HybridMime()
+    : HybridObject(HybridMimeSpec::TAG), ChilkatObject<CkMime>("Mime", CkMime::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridMime::HybridMime(CkMime* owned)
+    : HybridObject(HybridMimeSpec::TAG), ChilkatObject<CkMime>("Mime", owned) {
+  init();
+}
+
+void HybridMime::init() {
+}
+
+void HybridMime::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridMime::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMime::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMime::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMime::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMime::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridMime::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridMime::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridMime::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridMime::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridMime::getBoundary() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Boundary(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setBoundary(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "boundary");
+  this->ck().put_Boundary(value.c_str());
+}
+std::string HybridMime::getCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Charset(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "charset");
+  this->ck().put_Charset(value.c_str());
+}
+std::string HybridMime::getContentType() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ContentType(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setContentType(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "contentType");
+  this->ck().put_ContentType(value.c_str());
+}
+std::string HybridMime::getCurrentDateTime() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CurrentDateTime(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMime::getDisposition() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Disposition(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setDisposition(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "disposition");
+  this->ck().put_Disposition(value.c_str());
+}
+std::string HybridMime::getEncoding() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Encoding(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setEncoding(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "encoding");
+  this->ck().put_Encoding(value.c_str());
+}
+std::string HybridMime::getFilename() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Filename(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setFilename(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "filename");
+  this->ck().put_Filename(value.c_str());
+}
+std::string HybridMime::getMicalg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Micalg(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setMicalg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "micalg");
+  this->ck().put_Micalg(value.c_str());
+}
+std::string HybridMime::getNameParam() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Name(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setNameParam(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "nameParam");
+  this->ck().put_Name(value.c_str());
+}
+double HybridMime::getNumHeaderFields() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumHeaderFields());
+}
+double HybridMime::getNumParts() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumParts());
+}
+double HybridMime::getNumSignerCerts() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumSignerCerts());
+}
+std::string HybridMime::getPkcs7CryptAlg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Pkcs7CryptAlg(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setPkcs7CryptAlg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "pkcs7CryptAlg");
+  this->ck().put_Pkcs7CryptAlg(value.c_str());
+}
+double HybridMime::getPkcs7KeyLength() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Pkcs7KeyLength());
+}
+void HybridMime::setPkcs7KeyLength(double value) {
+  this->beginCall();
+  this->ck().put_Pkcs7KeyLength(rt::toInt(value, "pkcs7KeyLength"));
+}
+std::string HybridMime::getProtocol() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Protocol(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setProtocol(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "protocol");
+  this->ck().put_Protocol(value.c_str());
+}
+std::string HybridMime::getSigningHashAlg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SigningHashAlg(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setSigningHashAlg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "signingHashAlg");
+  this->ck().put_SigningHashAlg(value.c_str());
+}
+bool HybridMime::getUnwrapExtras() {
+  this->beginCall();
+  return this->ck().get_UnwrapExtras();
+}
+void HybridMime::setUnwrapExtras(bool value) {
+  this->beginCall();
+  this->ck().put_UnwrapExtras(value);
+}
+bool HybridMime::getUseMmDescription() {
+  this->beginCall();
+  return this->ck().get_UseMmDescription();
+}
+void HybridMime::setUseMmDescription(bool value) {
+  this->beginCall();
+  this->ck().put_UseMmDescription(value);
+}
+bool HybridMime::getUseXPkcs7() {
+  this->beginCall();
+  return this->ck().get_UseXPkcs7();
+}
+void HybridMime::setUseXPkcs7(bool value) {
+  this->beginCall();
+  this->ck().put_UseXPkcs7(value);
+}
+std::string HybridMime::getSigningAlg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SigningAlg(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setSigningAlg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "signingAlg");
+  this->ck().put_SigningAlg(value.c_str());
+}
+std::string HybridMime::getOaepHash() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OaepHash(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setOaepHash(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oaepHash");
+  this->ck().put_OaepHash(value.c_str());
+}
+bool HybridMime::getOaepPadding() {
+  this->beginCall();
+  return this->ck().get_OaepPadding();
+}
+void HybridMime::setOaepPadding(bool value) {
+  this->beginCall();
+  this->ck().put_OaepPadding(value);
+}
+std::string HybridMime::getOaepMgfHash() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OaepMgfHash(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setOaepMgfHash(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oaepMgfHash");
+  this->ck().put_OaepMgfHash(value.c_str());
+}
+std::string HybridMime::getCmsOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CmsOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setCmsOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "cmsOptions");
+  this->ck().put_CmsOptions(value.c_str());
+}
+std::string HybridMime::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridMime::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+double HybridMime::getNumDecryptCerts() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumDecryptCerts());
+}
+
+// ---- Methods ----
+
+void HybridMime::addContentLength() {
+  this->beginCall();
+  addContentLength_impl();
+}
+void HybridMime::addContentLength_impl() {
+  this->ck().AddContentLength();
+}
+
+void HybridMime::addDecryptCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  addDecryptCert_impl(cert);
+}
+void HybridMime::addDecryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().AddDecryptCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("addDecryptCert");
+}
+
+void HybridMime::addDetachedSignature(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  addDetachedSignature_impl(cert);
+}
+void HybridMime::addDetachedSignature_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().AddDetachedSignature(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("addDetachedSignature");
+}
+
+void HybridMime::addDetachedSignature2(const std::shared_ptr<HybridCertSpec>& cert, bool transferHeaderFields) {
+  this->beginCall();
+  addDetachedSignature2_impl(cert, transferHeaderFields);
+}
+void HybridMime::addDetachedSignature2_impl(const std::shared_ptr<HybridCertSpec>& cert, bool transferHeaderFields) {
+  if (!this->ck().AddDetachedSignature2(rt::implOf<HybridCert>(cert, "cert").ck(), transferHeaderFields)) throw this->fail("addDetachedSignature2");
+}
+
+void HybridMime::addDetachedSignaturePk(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) {
+  this->beginCall();
+  addDetachedSignaturePk_impl(cert, privateKey);
+}
+void HybridMime::addDetachedSignaturePk_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) {
+  if (!this->ck().AddDetachedSignaturePk(rt::implOf<HybridCert>(cert, "cert").ck(), rt::implOf<HybridPrivateKey>(privateKey, "privateKey").ck())) throw this->fail("addDetachedSignaturePk");
+}
+
+void HybridMime::addDetachedSignaturePk2(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey, bool transferHeaderFields) {
+  this->beginCall();
+  addDetachedSignaturePk2_impl(cert, privateKey, transferHeaderFields);
+}
+void HybridMime::addDetachedSignaturePk2_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey, bool transferHeaderFields) {
+  if (!this->ck().AddDetachedSignaturePk2(rt::implOf<HybridCert>(cert, "cert").ck(), rt::implOf<HybridPrivateKey>(privateKey, "privateKey").ck(), transferHeaderFields)) throw this->fail("addDetachedSignaturePk2");
+}
+
+void HybridMime::addEncryptCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  addEncryptCert_impl(cert);
+}
+void HybridMime::addEncryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().AddEncryptCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("addEncryptCert");
+}
+
+void HybridMime::addHeaderField(const std::string& name, const std::string& value) {
+  this->beginCall();
+  addHeaderField_impl(name, value);
+}
+void HybridMime::addHeaderField_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().AddHeaderField(name.c_str(), value.c_str())) throw this->fail("addHeaderField");
+}
+
+void HybridMime::addPfxSourceFile(const std::string& pfxFilePath, const std::string& password) {
+  this->beginCall();
+  addPfxSourceFile_impl(pfxFilePath, password);
+}
+void HybridMime::addPfxSourceFile_impl(const std::string& pfxFilePath, const std::string& password) {
+  rt::checkNoNul(pfxFilePath, "pfxFilePath");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().AddPfxSourceFile(pfxFilePath.c_str(), password.c_str())) throw this->fail("addPfxSourceFile");
+}
+
+void HybridMime::appendPart(const std::shared_ptr<HybridMimeSpec>& mime) {
+  this->beginCall();
+  appendPart_impl(mime);
+}
+void HybridMime::appendPart_impl(const std::shared_ptr<HybridMimeSpec>& mime) {
+  if (!this->ck().AppendPart(rt::implOf<HybridMime>(mime, "mime").ck())) throw this->fail("appendPart");
+}
+
+void HybridMime::appendPartFromFile(const std::string& filename) {
+  this->beginCall();
+  appendPartFromFile_impl(filename);
+}
+void HybridMime::appendPartFromFile_impl(const std::string& filename) {
+  rt::checkNoNul(filename, "filename");
+  if (!this->ck().AppendPartFromFile(filename.c_str())) throw this->fail("appendPartFromFile");
+}
+
+std::string HybridMime::asnBodyToXml() {
+  this->beginCall();
+  return asnBodyToXml_impl();
+}
+std::string HybridMime::asnBodyToXml_impl() {
+  CkString _out;
+  if (!this->ck().AsnBodyToXml(_out)) throw this->fail("asnBodyToXml");
+  return rt::stdString(_out);
+}
+
+void HybridMime::clearEncryptCerts() {
+  this->beginCall();
+  clearEncryptCerts_impl();
+}
+void HybridMime::clearEncryptCerts_impl() {
+  this->ck().ClearEncryptCerts();
+}
+
+bool HybridMime::containsEncryptedParts() {
+  this->beginCall();
+  return containsEncryptedParts_impl();
+}
+bool HybridMime::containsEncryptedParts_impl() {
+  return this->ck().ContainsEncryptedParts();
+}
+
+bool HybridMime::containsSignedParts() {
+  this->beginCall();
+  return containsSignedParts_impl();
+}
+bool HybridMime::containsSignedParts_impl() {
+  return this->ck().ContainsSignedParts();
+}
+
+void HybridMime::convert8Bit() {
+  this->beginCall();
+  convert8Bit_impl();
+}
+void HybridMime::convert8Bit_impl() {
+  this->ck().Convert8Bit();
+}
+
+void HybridMime::convertToMultipartAlt() {
+  this->beginCall();
+  convertToMultipartAlt_impl();
+}
+void HybridMime::convertToMultipartAlt_impl() {
+  if (!this->ck().ConvertToMultipartAlt()) throw this->fail("convertToMultipartAlt");
+}
+
+void HybridMime::convertToMultipartMixed() {
+  this->beginCall();
+  convertToMultipartMixed_impl();
+}
+void HybridMime::convertToMultipartMixed_impl() {
+  if (!this->ck().ConvertToMultipartMixed()) throw this->fail("convertToMultipartMixed");
+}
+
+void HybridMime::convertToSigned(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  convertToSigned_impl(cert);
+}
+void HybridMime::convertToSigned_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().ConvertToSigned(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("convertToSigned");
+}
+
+void HybridMime::convertToSignedPk(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) {
+  this->beginCall();
+  convertToSignedPk_impl(cert, privateKey);
+}
+void HybridMime::convertToSignedPk_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) {
+  if (!this->ck().ConvertToSignedPk(rt::implOf<HybridCert>(cert, "cert").ck(), rt::implOf<HybridPrivateKey>(privateKey, "privateKey").ck())) throw this->fail("convertToSignedPk");
+}
+
+void HybridMime::decrypt() {
+  this->beginCall();
+  decrypt_impl();
+}
+void HybridMime::decrypt_impl() {
+  if (!this->ck().Decrypt()) throw this->fail("decrypt");
+}
+
+void HybridMime::decrypt2(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) {
+  this->beginCall();
+  decrypt2_impl(cert, privateKey);
+}
+void HybridMime::decrypt2_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) {
+  if (!this->ck().Decrypt2(rt::implOf<HybridCert>(cert, "cert").ck(), rt::implOf<HybridPrivateKey>(privateKey, "privateKey").ck())) throw this->fail("decrypt2");
+}
+
+void HybridMime::decryptUsingCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  decryptUsingCert_impl(cert);
+}
+void HybridMime::decryptUsingCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().DecryptUsingCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("decryptUsingCert");
+}
+
+void HybridMime::decryptUsingPfxFile(const std::string& pfxFilePath, const std::string& pfxPassword) {
+  this->beginCall();
+  decryptUsingPfxFile_impl(pfxFilePath, pfxPassword);
+}
+void HybridMime::decryptUsingPfxFile_impl(const std::string& pfxFilePath, const std::string& pfxPassword) {
+  rt::checkNoNul(pfxFilePath, "pfxFilePath");
+  rt::checkNoNul(pfxPassword, "pfxPassword");
+  if (!this->ck().DecryptUsingPfxFile(pfxFilePath.c_str(), pfxPassword.c_str())) throw this->fail("decryptUsingPfxFile");
+}
+
+void HybridMime::encrypt(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  encrypt_impl(cert);
+}
+void HybridMime::encrypt_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().Encrypt(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("encrypt");
+}
+
+void HybridMime::encryptN() {
+  this->beginCall();
+  encryptN_impl();
+}
+void HybridMime::encryptN_impl() {
+  if (!this->ck().EncryptN()) throw this->fail("encryptN");
+}
+
+std::string HybridMime::getBodyDecoded() {
+  this->beginCall();
+  return getBodyDecoded_impl();
+}
+std::string HybridMime::getBodyDecoded_impl() {
+  CkString _out;
+  if (!this->ck().GetBodyDecoded(_out)) throw this->fail("getBodyDecoded");
+  return rt::stdString(_out);
+}
+
+std::string HybridMime::getBodyEncoded() {
+  this->beginCall();
+  return getBodyEncoded_impl();
+}
+std::string HybridMime::getBodyEncoded_impl() {
+  CkString _out;
+  if (!this->ck().GetBodyEncoded(_out)) throw this->fail("getBodyEncoded");
+  return rt::stdString(_out);
+}
+
+std::string HybridMime::getEntireBody() {
+  this->beginCall();
+  return getEntireBody_impl();
+}
+std::string HybridMime::getEntireBody_impl() {
+  CkString _out;
+  if (!this->ck().GetEntireBody(_out)) throw this->fail("getEntireBody");
+  return rt::stdString(_out);
+}
+
+std::string HybridMime::getEntireHead() {
+  this->beginCall();
+  return getEntireHead_impl();
+}
+std::string HybridMime::getEntireHead_impl() {
+  CkString _out;
+  if (!this->ck().GetEntireHead(_out)) throw this->fail("getEntireHead");
+  return rt::stdString(_out);
+}
+
+std::string HybridMime::getHeaderField(const std::string& fieldName) {
+  this->beginCall();
+  return getHeaderField_impl(fieldName);
+}
+std::string HybridMime::getHeaderField_impl(const std::string& fieldName) {
+  rt::checkNoNul(fieldName, "fieldName");
+  CkString _out;
+  if (!this->ck().GetHeaderField(fieldName.c_str(), _out)) throw this->fail("getHeaderField");
+  return rt::stdString(_out);
+}
+
+std::string HybridMime::getHeaderFieldAttribute(const std::string& name, const std::string& attrName) {
+  this->beginCall();
+  return getHeaderFieldAttribute_impl(name, attrName);
+}
+std::string HybridMime::getHeaderFieldAttribute_impl(const std::string& name, const std::string& attrName) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(attrName, "attrName");
+  CkString _out;
+  if (!this->ck().GetHeaderFieldAttribute(name.c_str(), attrName.c_str(), _out)) throw this->fail("getHeaderFieldAttribute");
+  return rt::stdString(_out);
+}
+
+std::string HybridMime::getHeaderFieldName(double index) {
+  this->beginCall();
+  return getHeaderFieldName_impl(index);
+}
+std::string HybridMime::getHeaderFieldName_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetHeaderFieldName(rt::toInt(index, "index"), _out)) throw this->fail("getHeaderFieldName");
+  return rt::stdString(_out);
+}
+
+std::string HybridMime::getHeaderFieldValue(double index) {
+  this->beginCall();
+  return getHeaderFieldValue_impl(index);
+}
+std::string HybridMime::getHeaderFieldValue_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetHeaderFieldValue(rt::toInt(index, "index"), _out)) throw this->fail("getHeaderFieldValue");
+  return rt::stdString(_out);
+}
+
+std::string HybridMime::getMime() {
+  this->beginCall();
+  return getMime_impl();
+}
+std::string HybridMime::getMime_impl() {
+  CkString _out;
+  if (!this->ck().GetMime(_out)) throw this->fail("getMime");
+  return rt::stdString(_out);
+}
+
+std::string HybridMime::getSignatureSigningTimeStr(double index) {
+  this->beginCall();
+  return getSignatureSigningTimeStr_impl(index);
+}
+std::string HybridMime::getSignatureSigningTimeStr_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetSignatureSigningTimeStr(rt::toInt(index, "index"), _out)) throw this->fail("getSignatureSigningTimeStr");
+  return rt::stdString(_out);
+}
+
+std::string HybridMime::getXml() {
+  this->beginCall();
+  return getXml_impl();
+}
+std::string HybridMime::getXml_impl() {
+  CkString _out;
+  if (!this->ck().GetXml(_out)) throw this->fail("getXml");
+  return rt::stdString(_out);
+}
+
+bool HybridMime::hasSignatureSigningTime(double index) {
+  this->beginCall();
+  return hasSignatureSigningTime_impl(index);
+}
+bool HybridMime::hasSignatureSigningTime_impl(double index) {
+  return this->ck().HasSignatureSigningTime(rt::toInt(index, "index"));
+}
+
+bool HybridMime::isApplicationData() {
+  this->beginCall();
+  return isApplicationData_impl();
+}
+bool HybridMime::isApplicationData_impl() {
+  return this->ck().IsApplicationData();
+}
+
+bool HybridMime::isAttachment() {
+  this->beginCall();
+  return isAttachment_impl();
+}
+bool HybridMime::isAttachment_impl() {
+  return this->ck().IsAttachment();
+}
+
+bool HybridMime::isAudio() {
+  this->beginCall();
+  return isAudio_impl();
+}
+bool HybridMime::isAudio_impl() {
+  return this->ck().IsAudio();
+}
+
+bool HybridMime::isEncrypted() {
+  this->beginCall();
+  return isEncrypted_impl();
+}
+bool HybridMime::isEncrypted_impl() {
+  return this->ck().IsEncrypted();
+}
+
+bool HybridMime::isHtml() {
+  this->beginCall();
+  return isHtml_impl();
+}
+bool HybridMime::isHtml_impl() {
+  return this->ck().IsHtml();
+}
+
+bool HybridMime::isImage() {
+  this->beginCall();
+  return isImage_impl();
+}
+bool HybridMime::isImage_impl() {
+  return this->ck().IsImage();
+}
+
+bool HybridMime::isMultipart() {
+  this->beginCall();
+  return isMultipart_impl();
+}
+bool HybridMime::isMultipart_impl() {
+  return this->ck().IsMultipart();
+}
+
+bool HybridMime::isMultipartAlternative() {
+  this->beginCall();
+  return isMultipartAlternative_impl();
+}
+bool HybridMime::isMultipartAlternative_impl() {
+  return this->ck().IsMultipartAlternative();
+}
+
+bool HybridMime::isMultipartMixed() {
+  this->beginCall();
+  return isMultipartMixed_impl();
+}
+bool HybridMime::isMultipartMixed_impl() {
+  return this->ck().IsMultipartMixed();
+}
+
+bool HybridMime::isMultipartRelated() {
+  this->beginCall();
+  return isMultipartRelated_impl();
+}
+bool HybridMime::isMultipartRelated_impl() {
+  return this->ck().IsMultipartRelated();
+}
+
+bool HybridMime::isPlainText() {
+  this->beginCall();
+  return isPlainText_impl();
+}
+bool HybridMime::isPlainText_impl() {
+  return this->ck().IsPlainText();
+}
+
+bool HybridMime::isSigned() {
+  this->beginCall();
+  return isSigned_impl();
+}
+bool HybridMime::isSigned_impl() {
+  return this->ck().IsSigned();
+}
+
+bool HybridMime::isText() {
+  this->beginCall();
+  return isText_impl();
+}
+bool HybridMime::isText_impl() {
+  return this->ck().IsText();
+}
+
+bool HybridMime::isVideo() {
+  this->beginCall();
+  return isVideo_impl();
+}
+bool HybridMime::isVideo_impl() {
+  return this->ck().IsVideo();
+}
+
+bool HybridMime::isXml() {
+  this->beginCall();
+  return isXml_impl();
+}
+bool HybridMime::isXml_impl() {
+  return this->ck().IsXml();
+}
+
+void HybridMime::loadMime(const std::string& mimeMsg) {
+  this->beginCall();
+  loadMime_impl(mimeMsg);
+}
+void HybridMime::loadMime_impl(const std::string& mimeMsg) {
+  rt::checkNoNul(mimeMsg, "mimeMsg");
+  if (!this->ck().LoadMime(mimeMsg.c_str())) throw this->fail("loadMime");
+}
+
+void HybridMime::loadMimeFile(const std::string& fileName) {
+  this->beginCall();
+  loadMimeFile_impl(fileName);
+}
+void HybridMime::loadMimeFile_impl(const std::string& fileName) {
+  rt::checkNoNul(fileName, "fileName");
+  if (!this->ck().LoadMimeFile(fileName.c_str())) throw this->fail("loadMimeFile");
+}
+
+void HybridMime::loadXml(const std::string& xml) {
+  this->beginCall();
+  loadXml_impl(xml);
+}
+void HybridMime::loadXml_impl(const std::string& xml) {
+  rt::checkNoNul(xml, "xml");
+  if (!this->ck().LoadXml(xml.c_str())) throw this->fail("loadXml");
+}
+
+void HybridMime::loadXmlFile(const std::string& fileName) {
+  this->beginCall();
+  loadXmlFile_impl(fileName);
+}
+void HybridMime::loadXmlFile_impl(const std::string& fileName) {
+  rt::checkNoNul(fileName, "fileName");
+  if (!this->ck().LoadXmlFile(fileName.c_str())) throw this->fail("loadXmlFile");
+}
+
+void HybridMime::newMessageRfc822(const std::shared_ptr<HybridMimeSpec>& mimeObject) {
+  this->beginCall();
+  newMessageRfc822_impl(mimeObject);
+}
+void HybridMime::newMessageRfc822_impl(const std::shared_ptr<HybridMimeSpec>& mimeObject) {
+  if (!this->ck().NewMessageRfc822(rt::implOf<HybridMime>(mimeObject, "mimeObject").ck())) throw this->fail("newMessageRfc822");
+}
+
+void HybridMime::newMultipartAlternative() {
+  this->beginCall();
+  newMultipartAlternative_impl();
+}
+void HybridMime::newMultipartAlternative_impl() {
+  if (!this->ck().NewMultipartAlternative()) throw this->fail("newMultipartAlternative");
+}
+
+void HybridMime::newMultipartMixed() {
+  this->beginCall();
+  newMultipartMixed_impl();
+}
+void HybridMime::newMultipartMixed_impl() {
+  if (!this->ck().NewMultipartMixed()) throw this->fail("newMultipartMixed");
+}
+
+void HybridMime::newMultipartRelated() {
+  this->beginCall();
+  newMultipartRelated_impl();
+}
+void HybridMime::newMultipartRelated_impl() {
+  if (!this->ck().NewMultipartRelated()) throw this->fail("newMultipartRelated");
+}
+
+void HybridMime::removeHeaderField(const std::string& fieldName, bool bAllOccurrences) {
+  this->beginCall();
+  removeHeaderField_impl(fieldName, bAllOccurrences);
+}
+void HybridMime::removeHeaderField_impl(const std::string& fieldName, bool bAllOccurrences) {
+  rt::checkNoNul(fieldName, "fieldName");
+  this->ck().RemoveHeaderField(fieldName.c_str(), bAllOccurrences);
+}
+
+void HybridMime::removePart(double index) {
+  this->beginCall();
+  removePart_impl(index);
+}
+void HybridMime::removePart_impl(double index) {
+  if (!this->ck().RemovePart(rt::toInt(index, "index"))) throw this->fail("removePart");
+}
+
+void HybridMime::saveBody(const std::string& filename) {
+  this->beginCall();
+  saveBody_impl(filename);
+}
+void HybridMime::saveBody_impl(const std::string& filename) {
+  rt::checkNoNul(filename, "filename");
+  if (!this->ck().SaveBody(filename.c_str())) throw this->fail("saveBody");
+}
+
+void HybridMime::saveMime(const std::string& filename) {
+  this->beginCall();
+  saveMime_impl(filename);
+}
+void HybridMime::saveMime_impl(const std::string& filename) {
+  rt::checkNoNul(filename, "filename");
+  if (!this->ck().SaveMime(filename.c_str())) throw this->fail("saveMime");
+}
+
+void HybridMime::saveXml(const std::string& filename) {
+  this->beginCall();
+  saveXml_impl(filename);
+}
+void HybridMime::saveXml_impl(const std::string& filename) {
+  rt::checkNoNul(filename, "filename");
+  if (!this->ck().SaveXml(filename.c_str())) throw this->fail("saveXml");
+}
+
+void HybridMime::setBody(const std::string& str) {
+  this->beginCall();
+  setBody_impl(str);
+}
+void HybridMime::setBody_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  this->ck().SetBody(str.c_str());
+}
+
+void HybridMime::setBodyFromEncoded(const std::string& encoding, const std::string& str) {
+  this->beginCall();
+  setBodyFromEncoded_impl(encoding, str);
+}
+void HybridMime::setBodyFromEncoded_impl(const std::string& encoding, const std::string& str) {
+  rt::checkNoNul(encoding, "encoding");
+  rt::checkNoNul(str, "str");
+  if (!this->ck().SetBodyFromEncoded(encoding.c_str(), str.c_str())) throw this->fail("setBodyFromEncoded");
+}
+
+void HybridMime::setBodyFromFile(const std::string& fileName) {
+  this->beginCall();
+  setBodyFromFile_impl(fileName);
+}
+void HybridMime::setBodyFromFile_impl(const std::string& fileName) {
+  rt::checkNoNul(fileName, "fileName");
+  if (!this->ck().SetBodyFromFile(fileName.c_str())) throw this->fail("setBodyFromFile");
+}
+
+void HybridMime::setBodyFromHtml(const std::string& str) {
+  this->beginCall();
+  setBodyFromHtml_impl(str);
+}
+void HybridMime::setBodyFromHtml_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  if (!this->ck().SetBodyFromHtml(str.c_str())) throw this->fail("setBodyFromHtml");
+}
+
+void HybridMime::setBodyFromPlainText(const std::string& str) {
+  this->beginCall();
+  setBodyFromPlainText_impl(str);
+}
+void HybridMime::setBodyFromPlainText_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  if (!this->ck().SetBodyFromPlainText(str.c_str())) throw this->fail("setBodyFromPlainText");
+}
+
+void HybridMime::setBodyFromXml(const std::string& str) {
+  this->beginCall();
+  setBodyFromXml_impl(str);
+}
+void HybridMime::setBodyFromXml_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  if (!this->ck().SetBodyFromXml(str.c_str())) throw this->fail("setBodyFromXml");
+}
+
+void HybridMime::setHeaderField(const std::string& name, const std::string& value) {
+  this->beginCall();
+  setHeaderField_impl(name, value);
+}
+void HybridMime::setHeaderField_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().SetHeaderField(name.c_str(), value.c_str())) throw this->fail("setHeaderField");
+}
+
+void HybridMime::setVerifyCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setVerifyCert_impl(cert);
+}
+void HybridMime::setVerifyCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetVerifyCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setVerifyCert");
+}
+
+void HybridMime::unwrapSecurity() {
+  this->beginCall();
+  unwrapSecurity_impl();
+}
+void HybridMime::unwrapSecurity_impl() {
+  if (!this->ck().UnwrapSecurity()) throw this->fail("unwrapSecurity");
+}
+
+void HybridMime::urlEncodeBody(const std::string& charset) {
+  this->beginCall();
+  urlEncodeBody_impl(charset);
+}
+void HybridMime::urlEncodeBody_impl(const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  this->ck().UrlEncodeBody(charset.c_str());
+}
+
+void HybridMime::useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  this->beginCall();
+  useCertVault_impl(vault);
+}
+void HybridMime::useCertVault_impl(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  if (!this->ck().UseCertVault(rt::implOf<HybridXmlCertVault>(vault, "vault").ck())) throw this->fail("useCertVault");
+}
+
+void HybridMime::verify() {
+  this->beginCall();
+  verify_impl();
+}
+void HybridMime::verify_impl() {
+  if (!this->ck().Verify()) throw this->fail("verify");
+}
+
+std::string HybridMime::getStructure(const std::string& fmt) {
+  this->beginCall();
+  return getStructure_impl(fmt);
+}
+std::string HybridMime::getStructure_impl(const std::string& fmt) {
+  rt::checkNoNul(fmt, "fmt");
+  CkString _out;
+  if (!this->ck().GetStructure(fmt.c_str(), _out)) throw this->fail("getStructure");
+  return rt::stdString(_out);
+}
+
+void HybridMime::getMimeSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  getMimeSb_impl(sb);
+}
+void HybridMime::getMimeSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().GetMimeSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("getMimeSb");
+}
+
+void HybridMime::getMimeBd(const std::shared_ptr<HybridBinDataSpec>& bindat) {
+  this->beginCall();
+  getMimeBd_impl(bindat);
+}
+void HybridMime::getMimeBd_impl(const std::shared_ptr<HybridBinDataSpec>& bindat) {
+  if (!this->ck().GetMimeBd(rt::implOf<HybridBinData>(bindat, "bindat").ck())) throw this->fail("getMimeBd");
+}
+
+void HybridMime::loadMimeSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  loadMimeSb_impl(sb);
+}
+void HybridMime::loadMimeSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().LoadMimeSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("loadMimeSb");
+}
+
+void HybridMime::loadMimeBd(const std::shared_ptr<HybridBinDataSpec>& bindat) {
+  this->beginCall();
+  loadMimeBd_impl(bindat);
+}
+void HybridMime::loadMimeBd_impl(const std::shared_ptr<HybridBinDataSpec>& bindat) {
+  if (!this->ck().LoadMimeBd(rt::implOf<HybridBinData>(bindat, "bindat").ck())) throw this->fail("loadMimeBd");
+}
+
+void HybridMime::getBodyBd(const std::shared_ptr<HybridBinDataSpec>& binDat) {
+  this->beginCall();
+  getBodyBd_impl(binDat);
+}
+void HybridMime::getBodyBd_impl(const std::shared_ptr<HybridBinDataSpec>& binDat) {
+  if (!this->ck().GetBodyBd(rt::implOf<HybridBinData>(binDat, "binDat").ck())) throw this->fail("getBodyBd");
+}
+
+void HybridMime::getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getLastJsonData_impl(json);
+}
+void HybridMime::getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->ck().GetLastJsonData(rt::implOf<HybridJsonObject>(json, "json").ck());
+}
+
+void HybridMime::lastDecryptCert(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  lastDecryptCert_impl(index, cert);
+}
+void HybridMime::lastDecryptCert_impl(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().LastDecryptCert(rt::toInt(index, "index"), rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("lastDecryptCert");
+}
+
+void HybridMime::lastSignerCert(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  lastSignerCert_impl(index, cert);
+}
+void HybridMime::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 HybridMime::partAt(double index, const std::shared_ptr<HybridMimeSpec>& subPart) {
+  this->beginCall();
+  partAt_impl(index, subPart);
+}
+void HybridMime::partAt_impl(double index, const std::shared_ptr<HybridMimeSpec>& subPart) {
+  if (!this->ck().PartAt(rt::toInt(index, "index"), rt::implOf<HybridMime>(subPart, "subPart").ck())) throw this->fail("partAt");
+}
+
+void HybridMime::partsToFiles(const std::string& path, const std::shared_ptr<HybridStringTableSpec>& st) {
+  this->beginCall();
+  partsToFiles_impl(path, st);
+}
+void HybridMime::partsToFiles_impl(const std::string& path, const std::shared_ptr<HybridStringTableSpec>& st) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().PartsToFiles(path.c_str(), rt::implOf<HybridStringTable>(st, "st").ck())) throw this->fail("partsToFiles");
+}
+
+void HybridMime::addPfxSourceBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) {
+  this->beginCall();
+  addPfxSourceBd_impl(bd, password);
+}
+void HybridMime::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");
+}
+
+void HybridMime::setBodyBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  setBodyBd_impl(bd);
+}
+void HybridMime::setBodyBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().SetBodyBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("setBodyBd");
+}
+
+void HybridMime::getDecryptCertInfo(const std::shared_ptr<HybridJsonObjectSpec>& certInfo) {
+  this->beginCall();
+  getDecryptCertInfo_impl(certInfo);
+}
+void HybridMime::getDecryptCertInfo_impl(const std::shared_ptr<HybridJsonObjectSpec>& certInfo) {
+  if (!this->ck().GetDecryptCertInfo(rt::implOf<HybridJsonObject>(certInfo, "certInfo").ck())) throw this->fail("getDecryptCertInfo");
+}
+
+} // namespace margelo::nitro::chilkat