@chilkat/react-native 11.6.1

package/cpp/HybridEmail.cpp

@@ -0,0 +1,1911 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridEmail.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCert.hpp"
+#include "HybridCkDateTime.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 {
+
+HybridEmail::HybridEmail()
+    : HybridObject(HybridEmailSpec::TAG), ChilkatObject<CkEmail>("Email", CkEmail::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridEmail::HybridEmail(CkEmail* owned)
+    : HybridObject(HybridEmailSpec::TAG), ChilkatObject<CkEmail>("Email", owned) {
+  init();
+}
+
+void HybridEmail::init() {
+}
+
+void HybridEmail::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridEmail::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEmail::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEmail::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEmail::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEmail::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridEmail::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridEmail::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridEmail::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridEmail::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridEmail::getBody() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Body(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setBody(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "body");
+  this->ck().put_Body(value.c_str());
+}
+std::string HybridEmail::getCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Charset(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "charset");
+  this->ck().put_Charset(value.c_str());
+}
+bool HybridEmail::getDecrypted() {
+  this->beginCall();
+  return this->ck().get_Decrypted();
+}
+std::string HybridEmail::getEmailDateStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_EmailDateStr(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setEmailDateStr(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "emailDateStr");
+  this->ck().put_EmailDateStr(value.c_str());
+}
+std::string HybridEmail::getEncryptedBy() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_EncryptedBy(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEmail::getFileDistList() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FileDistList(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setFileDistList(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "fileDistList");
+  this->ck().put_FileDistList(value.c_str());
+}
+std::string HybridEmail::getFrom() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_From(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setFrom(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "from");
+  this->ck().put_From(value.c_str());
+}
+std::string HybridEmail::getFromAddress() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FromAddress(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setFromAddress(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "fromAddress");
+  this->ck().put_FromAddress(value.c_str());
+}
+std::string HybridEmail::getFromName() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FromName(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setFromName(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "fromName");
+  this->ck().put_FromName(value.c_str());
+}
+std::string HybridEmail::getHeader() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Header(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEmail::getLanguage() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Language(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEmail::getLocalDateStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LocalDateStr(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setLocalDateStr(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "localDateStr");
+  this->ck().put_LocalDateStr(value.c_str());
+}
+std::string HybridEmail::getMailer() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Mailer(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setMailer(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "mailer");
+  this->ck().put_Mailer(value.c_str());
+}
+double HybridEmail::getNumAlternatives() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumAlternatives());
+}
+double HybridEmail::getNumAttachedMessages() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumAttachedMessages());
+}
+double HybridEmail::getNumAttachments() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumAttachments());
+}
+double HybridEmail::getNumBcc() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumBcc());
+}
+double HybridEmail::getNumCC() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumCC());
+}
+double HybridEmail::getNumDaysOld() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumDaysOld());
+}
+double HybridEmail::getNumHeaderFields() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumHeaderFields());
+}
+double HybridEmail::getNumRelatedItems() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumRelatedItems());
+}
+double HybridEmail::getNumReplacePatterns() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumReplacePatterns());
+}
+double HybridEmail::getNumReports() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumReports());
+}
+double HybridEmail::getNumTo() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumTo());
+}
+bool HybridEmail::getOverwriteExisting() {
+  this->beginCall();
+  return this->ck().get_OverwriteExisting();
+}
+void HybridEmail::setOverwriteExisting(bool value) {
+  this->beginCall();
+  this->ck().put_OverwriteExisting(value);
+}
+std::string HybridEmail::getPkcs7CryptAlg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Pkcs7CryptAlg(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setPkcs7CryptAlg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "pkcs7CryptAlg");
+  this->ck().put_Pkcs7CryptAlg(value.c_str());
+}
+double HybridEmail::getPkcs7KeyLength() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Pkcs7KeyLength());
+}
+void HybridEmail::setPkcs7KeyLength(double value) {
+  this->beginCall();
+  this->ck().put_Pkcs7KeyLength(rt::toInt(value, "pkcs7KeyLength"));
+}
+std::string HybridEmail::getPreferredCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_PreferredCharset(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setPreferredCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "preferredCharset");
+  this->ck().put_PreferredCharset(value.c_str());
+}
+bool HybridEmail::getPrependHeaders() {
+  this->beginCall();
+  return this->ck().get_PrependHeaders();
+}
+void HybridEmail::setPrependHeaders(bool value) {
+  this->beginCall();
+  this->ck().put_PrependHeaders(value);
+}
+bool HybridEmail::getReceivedEncrypted() {
+  this->beginCall();
+  return this->ck().get_ReceivedEncrypted();
+}
+bool HybridEmail::getReceivedSigned() {
+  this->beginCall();
+  return this->ck().get_ReceivedSigned();
+}
+std::string HybridEmail::getReplyTo() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ReplyTo(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setReplyTo(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "replyTo");
+  this->ck().put_ReplyTo(value.c_str());
+}
+bool HybridEmail::getReturnReceipt() {
+  this->beginCall();
+  return this->ck().get_ReturnReceipt();
+}
+void HybridEmail::setReturnReceipt(bool value) {
+  this->beginCall();
+  this->ck().put_ReturnReceipt(value);
+}
+bool HybridEmail::getSendEncrypted() {
+  this->beginCall();
+  return this->ck().get_SendEncrypted();
+}
+void HybridEmail::setSendEncrypted(bool value) {
+  this->beginCall();
+  this->ck().put_SendEncrypted(value);
+}
+bool HybridEmail::getSendSigned() {
+  this->beginCall();
+  return this->ck().get_SendSigned();
+}
+void HybridEmail::setSendSigned(bool value) {
+  this->beginCall();
+  this->ck().put_SendSigned(value);
+}
+bool HybridEmail::getSignaturesValid() {
+  this->beginCall();
+  return this->ck().get_SignaturesValid();
+}
+std::string HybridEmail::getSignedBy() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SignedBy(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEmail::getSigningHashAlg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SigningHashAlg(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setSigningHashAlg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "signingHashAlg");
+  this->ck().put_SigningHashAlg(value.c_str());
+}
+double HybridEmail::getSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Size());
+}
+std::string HybridEmail::getSubject() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Subject(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setSubject(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "subject");
+  this->ck().put_Subject(value.c_str());
+}
+std::string HybridEmail::getUidl() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Uidl(_s);
+  return rt::stdString(_s);
+}
+bool HybridEmail::getUnpackUseRelPaths() {
+  this->beginCall();
+  return this->ck().get_UnpackUseRelPaths();
+}
+void HybridEmail::setUnpackUseRelPaths(bool value) {
+  this->beginCall();
+  this->ck().put_UnpackUseRelPaths(value);
+}
+double HybridEmail::getNumDigests() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumDigests());
+}
+std::string HybridEmail::getSigningAlg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SigningAlg(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setSigningAlg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "signingAlg");
+  this->ck().put_SigningAlg(value.c_str());
+}
+bool HybridEmail::getOaepPadding() {
+  this->beginCall();
+  return this->ck().get_OaepPadding();
+}
+void HybridEmail::setOaepPadding(bool value) {
+  this->beginCall();
+  this->ck().put_OaepPadding(value);
+}
+std::string HybridEmail::getOaepHash() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OaepHash(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setOaepHash(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oaepHash");
+  this->ck().put_OaepHash(value.c_str());
+}
+std::string HybridEmail::getOaepMgfHash() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OaepMgfHash(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setOaepMgfHash(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oaepMgfHash");
+  this->ck().put_OaepMgfHash(value.c_str());
+}
+std::string HybridEmail::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridEmail::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridEmail::addAttachmentHeader(double index, const std::string& fieldName, const std::string& fieldValue) {
+  this->beginCall();
+  addAttachmentHeader_impl(index, fieldName, fieldValue);
+}
+void HybridEmail::addAttachmentHeader_impl(double index, const std::string& fieldName, const std::string& fieldValue) {
+  rt::checkNoNul(fieldName, "fieldName");
+  rt::checkNoNul(fieldValue, "fieldValue");
+  this->ck().AddAttachmentHeader(rt::toInt(index, "index"), fieldName.c_str(), fieldValue.c_str());
+}
+
+void HybridEmail::addBcc(const std::string& friendlyName, const std::string& emailAddress) {
+  this->beginCall();
+  addBcc_impl(friendlyName, emailAddress);
+}
+void HybridEmail::addBcc_impl(const std::string& friendlyName, const std::string& emailAddress) {
+  rt::checkNoNul(friendlyName, "friendlyName");
+  rt::checkNoNul(emailAddress, "emailAddress");
+  if (!this->ck().AddBcc(friendlyName.c_str(), emailAddress.c_str())) throw this->fail("addBcc");
+}
+
+void HybridEmail::addCC(const std::string& friendlyName, const std::string& emailAddress) {
+  this->beginCall();
+  addCC_impl(friendlyName, emailAddress);
+}
+void HybridEmail::addCC_impl(const std::string& friendlyName, const std::string& emailAddress) {
+  rt::checkNoNul(friendlyName, "friendlyName");
+  rt::checkNoNul(emailAddress, "emailAddress");
+  if (!this->ck().AddCC(friendlyName.c_str(), emailAddress.c_str())) throw this->fail("addCC");
+}
+
+void HybridEmail::addEncryptCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  addEncryptCert_impl(cert);
+}
+void HybridEmail::addEncryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().AddEncryptCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("addEncryptCert");
+}
+
+std::string HybridEmail::addFileAttachment(const std::string& path) {
+  this->beginCall();
+  return addFileAttachment_impl(path);
+}
+std::string HybridEmail::addFileAttachment_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  CkString _out;
+  if (!this->ck().AddFileAttachment(path.c_str(), _out)) throw this->fail("addFileAttachment");
+  return rt::stdString(_out);
+}
+
+void HybridEmail::addFileAttachment2(const std::string& path, const std::string& contentType) {
+  this->beginCall();
+  addFileAttachment2_impl(path, contentType);
+}
+void HybridEmail::addFileAttachment2_impl(const std::string& path, const std::string& contentType) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(contentType, "contentType");
+  if (!this->ck().AddFileAttachment2(path.c_str(), contentType.c_str())) throw this->fail("addFileAttachment2");
+}
+
+void HybridEmail::addHeaderField(const std::string& fieldName, const std::string& fieldValue) {
+  this->beginCall();
+  addHeaderField_impl(fieldName, fieldValue);
+}
+void HybridEmail::addHeaderField_impl(const std::string& fieldName, const std::string& fieldValue) {
+  rt::checkNoNul(fieldName, "fieldName");
+  rt::checkNoNul(fieldValue, "fieldValue");
+  this->ck().AddHeaderField(fieldName.c_str(), fieldValue.c_str());
+}
+
+void HybridEmail::addHeaderField2(const std::string& fieldName, const std::string& fieldValue) {
+  this->beginCall();
+  addHeaderField2_impl(fieldName, fieldValue);
+}
+void HybridEmail::addHeaderField2_impl(const std::string& fieldName, const std::string& fieldValue) {
+  rt::checkNoNul(fieldName, "fieldName");
+  rt::checkNoNul(fieldValue, "fieldValue");
+  this->ck().AddHeaderField2(fieldName.c_str(), fieldValue.c_str());
+}
+
+void HybridEmail::addHtmlAlternativeBody(const std::string& body) {
+  this->beginCall();
+  addHtmlAlternativeBody_impl(body);
+}
+void HybridEmail::addHtmlAlternativeBody_impl(const std::string& body) {
+  rt::checkNoNul(body, "body");
+  if (!this->ck().AddHtmlAlternativeBody(body.c_str())) throw this->fail("addHtmlAlternativeBody");
+}
+
+void HybridEmail::addMultipleBcc(const std::string& commaSeparatedAddresses) {
+  this->beginCall();
+  addMultipleBcc_impl(commaSeparatedAddresses);
+}
+void HybridEmail::addMultipleBcc_impl(const std::string& commaSeparatedAddresses) {
+  rt::checkNoNul(commaSeparatedAddresses, "commaSeparatedAddresses");
+  if (!this->ck().AddMultipleBcc(commaSeparatedAddresses.c_str())) throw this->fail("addMultipleBcc");
+}
+
+void HybridEmail::addMultipleCC(const std::string& commaSeparatedAddresses) {
+  this->beginCall();
+  addMultipleCC_impl(commaSeparatedAddresses);
+}
+void HybridEmail::addMultipleCC_impl(const std::string& commaSeparatedAddresses) {
+  rt::checkNoNul(commaSeparatedAddresses, "commaSeparatedAddresses");
+  if (!this->ck().AddMultipleCC(commaSeparatedAddresses.c_str())) throw this->fail("addMultipleCC");
+}
+
+void HybridEmail::addMultipleTo(const std::string& commaSeparatedAddresses) {
+  this->beginCall();
+  addMultipleTo_impl(commaSeparatedAddresses);
+}
+void HybridEmail::addMultipleTo_impl(const std::string& commaSeparatedAddresses) {
+  rt::checkNoNul(commaSeparatedAddresses, "commaSeparatedAddresses");
+  if (!this->ck().AddMultipleTo(commaSeparatedAddresses.c_str())) throw this->fail("addMultipleTo");
+}
+
+void HybridEmail::addPfxSourceFile(const std::string& pfxFilePath, const std::string& pfxPassword) {
+  this->beginCall();
+  addPfxSourceFile_impl(pfxFilePath, pfxPassword);
+}
+void HybridEmail::addPfxSourceFile_impl(const std::string& pfxFilePath, const std::string& pfxPassword) {
+  rt::checkNoNul(pfxFilePath, "pfxFilePath");
+  rt::checkNoNul(pfxPassword, "pfxPassword");
+  if (!this->ck().AddPfxSourceFile(pfxFilePath.c_str(), pfxPassword.c_str())) throw this->fail("addPfxSourceFile");
+}
+
+void HybridEmail::addPlainTextAlternativeBody(const std::string& body) {
+  this->beginCall();
+  addPlainTextAlternativeBody_impl(body);
+}
+void HybridEmail::addPlainTextAlternativeBody_impl(const std::string& body) {
+  rt::checkNoNul(body, "body");
+  if (!this->ck().AddPlainTextAlternativeBody(body.c_str())) throw this->fail("addPlainTextAlternativeBody");
+}
+
+std::string HybridEmail::addRelatedFile(const std::string& path) {
+  this->beginCall();
+  return addRelatedFile_impl(path);
+}
+std::string HybridEmail::addRelatedFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  CkString _out;
+  if (!this->ck().AddRelatedFile(path.c_str(), _out)) throw this->fail("addRelatedFile");
+  return rt::stdString(_out);
+}
+
+void HybridEmail::addRelatedFile2(const std::string& filenameOnDisk, const std::string& filenameInHtml) {
+  this->beginCall();
+  addRelatedFile2_impl(filenameOnDisk, filenameInHtml);
+}
+void HybridEmail::addRelatedFile2_impl(const std::string& filenameOnDisk, const std::string& filenameInHtml) {
+  rt::checkNoNul(filenameOnDisk, "filenameOnDisk");
+  rt::checkNoNul(filenameInHtml, "filenameInHtml");
+  if (!this->ck().AddRelatedFile2(filenameOnDisk.c_str(), filenameInHtml.c_str())) throw this->fail("addRelatedFile2");
+}
+
+void HybridEmail::addRelatedHeader(double index, const std::string& fieldName, const std::string& fieldValue) {
+  this->beginCall();
+  addRelatedHeader_impl(index, fieldName, fieldValue);
+}
+void HybridEmail::addRelatedHeader_impl(double index, const std::string& fieldName, const std::string& fieldValue) {
+  rt::checkNoNul(fieldName, "fieldName");
+  rt::checkNoNul(fieldValue, "fieldValue");
+  this->ck().AddRelatedHeader(rt::toInt(index, "index"), fieldName.c_str(), fieldValue.c_str());
+}
+
+std::string HybridEmail::addRelatedString(const std::string& nameInHtml, const std::string& str, const std::string& charset) {
+  this->beginCall();
+  return addRelatedString_impl(nameInHtml, str, charset);
+}
+std::string HybridEmail::addRelatedString_impl(const std::string& nameInHtml, const std::string& str, const std::string& charset) {
+  rt::checkNoNul(nameInHtml, "nameInHtml");
+  rt::checkNoNul(str, "str");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().AddRelatedString(nameInHtml.c_str(), str.c_str(), charset.c_str(), _out)) throw this->fail("addRelatedString");
+  return rt::stdString(_out);
+}
+
+void HybridEmail::addRelatedString2(const std::string& fileNameInHtml, const std::string& content, const std::string& charset) {
+  this->beginCall();
+  addRelatedString2_impl(fileNameInHtml, content, charset);
+}
+void HybridEmail::addRelatedString2_impl(const std::string& fileNameInHtml, const std::string& content, const std::string& charset) {
+  rt::checkNoNul(fileNameInHtml, "fileNameInHtml");
+  rt::checkNoNul(content, "content");
+  rt::checkNoNul(charset, "charset");
+  this->ck().AddRelatedString2(fileNameInHtml.c_str(), content.c_str(), charset.c_str());
+}
+
+void HybridEmail::addStringAttachment(const std::string& path, const std::string& content) {
+  this->beginCall();
+  addStringAttachment_impl(path, content);
+}
+void HybridEmail::addStringAttachment_impl(const std::string& path, const std::string& content) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(content, "content");
+  if (!this->ck().AddStringAttachment(path.c_str(), content.c_str())) throw this->fail("addStringAttachment");
+}
+
+void HybridEmail::addStringAttachment2(const std::string& path, const std::string& content, const std::string& charset) {
+  this->beginCall();
+  addStringAttachment2_impl(path, content, charset);
+}
+void HybridEmail::addStringAttachment2_impl(const std::string& path, const std::string& content, const std::string& charset) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(content, "content");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().AddStringAttachment2(path.c_str(), content.c_str(), charset.c_str())) throw this->fail("addStringAttachment2");
+}
+
+void HybridEmail::addTo(const std::string& friendlyName, const std::string& emailAddress) {
+  this->beginCall();
+  addTo_impl(friendlyName, emailAddress);
+}
+void HybridEmail::addTo_impl(const std::string& friendlyName, const std::string& emailAddress) {
+  rt::checkNoNul(friendlyName, "friendlyName");
+  rt::checkNoNul(emailAddress, "emailAddress");
+  if (!this->ck().AddTo(friendlyName.c_str(), emailAddress.c_str())) throw this->fail("addTo");
+}
+
+void HybridEmail::addiCalendarAlternativeBody(const std::string& icalContent, const std::string& methodName) {
+  this->beginCall();
+  addiCalendarAlternativeBody_impl(icalContent, methodName);
+}
+void HybridEmail::addiCalendarAlternativeBody_impl(const std::string& icalContent, const std::string& methodName) {
+  rt::checkNoNul(icalContent, "icalContent");
+  rt::checkNoNul(methodName, "methodName");
+  if (!this->ck().AddiCalendarAlternativeBody(icalContent.c_str(), methodName.c_str())) throw this->fail("addiCalendarAlternativeBody");
+}
+
+void HybridEmail::aesDecrypt(const std::string& password) {
+  this->beginCall();
+  aesDecrypt_impl(password);
+}
+void HybridEmail::aesDecrypt_impl(const std::string& password) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().AesDecrypt(password.c_str())) throw this->fail("aesDecrypt");
+}
+
+void HybridEmail::aesEncrypt(const std::string& password) {
+  this->beginCall();
+  aesEncrypt_impl(password);
+}
+void HybridEmail::aesEncrypt_impl(const std::string& password) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().AesEncrypt(password.c_str())) throw this->fail("aesEncrypt");
+}
+
+void HybridEmail::appendToBody(const std::string& str) {
+  this->beginCall();
+  appendToBody_impl(str);
+}
+void HybridEmail::appendToBody_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  this->ck().AppendToBody(str.c_str());
+}
+
+void HybridEmail::aspUnpack(const std::string& prefix, const std::string& saveDir, const std::string& urlPath, bool cleanFiles) {
+  this->beginCall();
+  aspUnpack_impl(prefix, saveDir, urlPath, cleanFiles);
+}
+void HybridEmail::aspUnpack_impl(const std::string& prefix, const std::string& saveDir, const std::string& urlPath, bool cleanFiles) {
+  rt::checkNoNul(prefix, "prefix");
+  rt::checkNoNul(saveDir, "saveDir");
+  rt::checkNoNul(urlPath, "urlPath");
+  if (!this->ck().AspUnpack(prefix.c_str(), saveDir.c_str(), urlPath.c_str(), cleanFiles)) throw this->fail("aspUnpack");
+}
+
+std::string HybridEmail::bEncodeString(const std::string& str, const std::string& charset) {
+  this->beginCall();
+  return bEncodeString_impl(str, charset);
+}
+std::string HybridEmail::bEncodeString_impl(const std::string& str, const std::string& charset) {
+  rt::checkNoNul(str, "str");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().BEncodeString(str.c_str(), charset.c_str(), _out)) throw this->fail("bEncodeString");
+  return rt::stdString(_out);
+}
+
+void HybridEmail::clearBcc() {
+  this->beginCall();
+  clearBcc_impl();
+}
+void HybridEmail::clearBcc_impl() {
+  this->ck().ClearBcc();
+}
+
+void HybridEmail::clearCC() {
+  this->beginCall();
+  clearCC_impl();
+}
+void HybridEmail::clearCC_impl() {
+  this->ck().ClearCC();
+}
+
+void HybridEmail::clearEncryptCerts() {
+  this->beginCall();
+  clearEncryptCerts_impl();
+}
+void HybridEmail::clearEncryptCerts_impl() {
+  this->ck().ClearEncryptCerts();
+}
+
+void HybridEmail::clearTo() {
+  this->beginCall();
+  clearTo_impl();
+}
+void HybridEmail::clearTo_impl() {
+  this->ck().ClearTo();
+}
+
+std::string HybridEmail::createTempMht(const std::string& inFilename) {
+  this->beginCall();
+  return createTempMht_impl(inFilename);
+}
+std::string HybridEmail::createTempMht_impl(const std::string& inFilename) {
+  rt::checkNoNul(inFilename, "inFilename");
+  CkString _out;
+  if (!this->ck().CreateTempMht(inFilename.c_str(), _out)) throw this->fail("createTempMht");
+  return rt::stdString(_out);
+}
+
+void HybridEmail::dropAttachments() {
+  this->beginCall();
+  dropAttachments_impl();
+}
+void HybridEmail::dropAttachments_impl() {
+  this->ck().DropAttachments();
+}
+
+void HybridEmail::dropRelatedItem(double index) {
+  this->beginCall();
+  dropRelatedItem_impl(index);
+}
+void HybridEmail::dropRelatedItem_impl(double index) {
+  this->ck().DropRelatedItem(rt::toInt(index, "index"));
+}
+
+void HybridEmail::dropRelatedItems() {
+  this->beginCall();
+  dropRelatedItems_impl();
+}
+void HybridEmail::dropRelatedItems_impl() {
+  this->ck().DropRelatedItems();
+}
+
+void HybridEmail::dropSingleAttachment(double index) {
+  this->beginCall();
+  dropSingleAttachment_impl(index);
+}
+void HybridEmail::dropSingleAttachment_impl(double index) {
+  if (!this->ck().DropSingleAttachment(rt::toInt(index, "index"))) throw this->fail("dropSingleAttachment");
+}
+
+std::string HybridEmail::generateFilename() {
+  this->beginCall();
+  return generateFilename_impl();
+}
+std::string HybridEmail::generateFilename_impl() {
+  CkString _out;
+  if (!this->ck().GenerateFilename(_out)) throw this->fail("generateFilename");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getAltHeaderField(double index, const std::string& fieldName) {
+  this->beginCall();
+  return getAltHeaderField_impl(index, fieldName);
+}
+std::string HybridEmail::getAltHeaderField_impl(double index, const std::string& fieldName) {
+  rt::checkNoNul(fieldName, "fieldName");
+  CkString _out;
+  if (!this->ck().GetAltHeaderField(rt::toInt(index, "index"), fieldName.c_str(), _out)) throw this->fail("getAltHeaderField");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getAlternativeBody(double index) {
+  this->beginCall();
+  return getAlternativeBody_impl(index);
+}
+std::string HybridEmail::getAlternativeBody_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetAlternativeBody(rt::toInt(index, "index"), _out)) throw this->fail("getAlternativeBody");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getAlternativeBodyByContentType(const std::string& contentType) {
+  this->beginCall();
+  return getAlternativeBodyByContentType_impl(contentType);
+}
+std::string HybridEmail::getAlternativeBodyByContentType_impl(const std::string& contentType) {
+  rt::checkNoNul(contentType, "contentType");
+  CkString _out;
+  if (!this->ck().GetAlternativeBodyByContentType(contentType.c_str(), _out)) throw this->fail("getAlternativeBodyByContentType");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getAlternativeContentType(double index) {
+  this->beginCall();
+  return getAlternativeContentType_impl(index);
+}
+std::string HybridEmail::getAlternativeContentType_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetAlternativeContentType(rt::toInt(index, "index"), _out)) throw this->fail("getAlternativeContentType");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getAttachedMessageAttr(double index, const std::string& fieldName, const std::string& attrName) {
+  this->beginCall();
+  return getAttachedMessageAttr_impl(index, fieldName, attrName);
+}
+std::string HybridEmail::getAttachedMessageAttr_impl(double index, const std::string& fieldName, const std::string& attrName) {
+  rt::checkNoNul(fieldName, "fieldName");
+  rt::checkNoNul(attrName, "attrName");
+  CkString _out;
+  if (!this->ck().GetAttachedMessageAttr(rt::toInt(index, "index"), fieldName.c_str(), attrName.c_str(), _out)) throw this->fail("getAttachedMessageAttr");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getAttachedMessageFilename(double index) {
+  this->beginCall();
+  return getAttachedMessageFilename_impl(index);
+}
+std::string HybridEmail::getAttachedMessageFilename_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetAttachedMessageFilename(rt::toInt(index, "index"), _out)) throw this->fail("getAttachedMessageFilename");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getAttachmentAttr(double index, const std::string& fieldName, const std::string& attrName) {
+  this->beginCall();
+  return getAttachmentAttr_impl(index, fieldName, attrName);
+}
+std::string HybridEmail::getAttachmentAttr_impl(double index, const std::string& fieldName, const std::string& attrName) {
+  rt::checkNoNul(fieldName, "fieldName");
+  rt::checkNoNul(attrName, "attrName");
+  CkString _out;
+  if (!this->ck().GetAttachmentAttr(rt::toInt(index, "index"), fieldName.c_str(), attrName.c_str(), _out)) throw this->fail("getAttachmentAttr");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getAttachmentContentID(double index) {
+  this->beginCall();
+  return getAttachmentContentID_impl(index);
+}
+std::string HybridEmail::getAttachmentContentID_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetAttachmentContentID(rt::toInt(index, "index"), _out)) throw this->fail("getAttachmentContentID");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getAttachmentContentType(double index) {
+  this->beginCall();
+  return getAttachmentContentType_impl(index);
+}
+std::string HybridEmail::getAttachmentContentType_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetAttachmentContentType(rt::toInt(index, "index"), _out)) throw this->fail("getAttachmentContentType");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getAttachmentFilename(double index) {
+  this->beginCall();
+  return getAttachmentFilename_impl(index);
+}
+std::string HybridEmail::getAttachmentFilename_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetAttachmentFilename(rt::toInt(index, "index"), _out)) throw this->fail("getAttachmentFilename");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getAttachmentHeader(double attachIndex, const std::string& fieldName) {
+  this->beginCall();
+  return getAttachmentHeader_impl(attachIndex, fieldName);
+}
+std::string HybridEmail::getAttachmentHeader_impl(double attachIndex, const std::string& fieldName) {
+  rt::checkNoNul(fieldName, "fieldName");
+  CkString _out;
+  if (!this->ck().GetAttachmentHeader(rt::toInt(attachIndex, "attachIndex"), fieldName.c_str(), _out)) throw this->fail("getAttachmentHeader");
+  return rt::stdString(_out);
+}
+
+double HybridEmail::getAttachmentSize(double index) {
+  this->beginCall();
+  return getAttachmentSize_impl(index);
+}
+double HybridEmail::getAttachmentSize_impl(double index) {
+  return static_cast<double>(this->ck().GetAttachmentSize(rt::toInt(index, "index")));
+}
+
+std::string HybridEmail::getAttachmentString(double index, const std::string& charset) {
+  this->beginCall();
+  return getAttachmentString_impl(index, charset);
+}
+std::string HybridEmail::getAttachmentString_impl(double index, const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().GetAttachmentString(rt::toInt(index, "index"), charset.c_str(), _out)) throw this->fail("getAttachmentString");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getAttachmentStringCrLf(double index, const std::string& charset) {
+  this->beginCall();
+  return getAttachmentStringCrLf_impl(index, charset);
+}
+std::string HybridEmail::getAttachmentStringCrLf_impl(double index, const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().GetAttachmentStringCrLf(rt::toInt(index, "index"), charset.c_str(), _out)) throw this->fail("getAttachmentStringCrLf");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getBcc(double index) {
+  this->beginCall();
+  return getBcc_impl(index);
+}
+std::string HybridEmail::getBcc_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetBcc(rt::toInt(index, "index"), _out)) throw this->fail("getBcc");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getBccAddr(double index) {
+  this->beginCall();
+  return getBccAddr_impl(index);
+}
+std::string HybridEmail::getBccAddr_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetBccAddr(rt::toInt(index, "index"), _out)) throw this->fail("getBccAddr");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getBccName(double index) {
+  this->beginCall();
+  return getBccName_impl(index);
+}
+std::string HybridEmail::getBccName_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetBccName(rt::toInt(index, "index"), _out)) throw this->fail("getBccName");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getCC(double index) {
+  this->beginCall();
+  return getCC_impl(index);
+}
+std::string HybridEmail::getCC_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetCC(rt::toInt(index, "index"), _out)) throw this->fail("getCC");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getCcAddr(double index) {
+  this->beginCall();
+  return getCcAddr_impl(index);
+}
+std::string HybridEmail::getCcAddr_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetCcAddr(rt::toInt(index, "index"), _out)) throw this->fail("getCcAddr");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getCcName(double index) {
+  this->beginCall();
+  return getCcName_impl(index);
+}
+std::string HybridEmail::getCcName_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetCcName(rt::toInt(index, "index"), _out)) throw this->fail("getCcName");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getDeliveryStatusInfo(const std::string& fieldName) {
+  this->beginCall();
+  return getDeliveryStatusInfo_impl(fieldName);
+}
+std::string HybridEmail::getDeliveryStatusInfo_impl(const std::string& fieldName) {
+  rt::checkNoNul(fieldName, "fieldName");
+  CkString _out;
+  if (!this->ck().GetDeliveryStatusInfo(fieldName.c_str(), _out)) throw this->fail("getDeliveryStatusInfo");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getHeaderField(const std::string& fieldName) {
+  this->beginCall();
+  return getHeaderField_impl(fieldName);
+}
+std::string HybridEmail::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 HybridEmail::getHeaderFieldName(double index) {
+  this->beginCall();
+  return getHeaderFieldName_impl(index);
+}
+std::string HybridEmail::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 HybridEmail::getHeaderFieldValue(double index) {
+  this->beginCall();
+  return getHeaderFieldValue_impl(index);
+}
+std::string HybridEmail::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 HybridEmail::getHtmlBody() {
+  this->beginCall();
+  return getHtmlBody_impl();
+}
+std::string HybridEmail::getHtmlBody_impl() {
+  CkString _out;
+  if (!this->ck().GetHtmlBody(_out)) throw this->fail("getHtmlBody");
+  return rt::stdString(_out);
+}
+
+double HybridEmail::getImapUid() {
+  this->beginCall();
+  return getImapUid_impl();
+}
+double HybridEmail::getImapUid_impl() {
+  return static_cast<double>(this->ck().GetImapUid());
+}
+
+std::string HybridEmail::getMime() {
+  this->beginCall();
+  return getMime_impl();
+}
+std::string HybridEmail::getMime_impl() {
+  CkString _out;
+  if (!this->ck().GetMime(_out)) throw this->fail("getMime");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getNthTextPartOfType(double index, const std::string& contentType, bool inlineOnly, bool excludeAttachments) {
+  this->beginCall();
+  return getNthTextPartOfType_impl(index, contentType, inlineOnly, excludeAttachments);
+}
+std::string HybridEmail::getNthTextPartOfType_impl(double index, const std::string& contentType, bool inlineOnly, bool excludeAttachments) {
+  rt::checkNoNul(contentType, "contentType");
+  CkString _out;
+  if (!this->ck().GetNthTextPartOfType(rt::toInt(index, "index"), contentType.c_str(), inlineOnly, excludeAttachments, _out)) throw this->fail("getNthTextPartOfType");
+  return rt::stdString(_out);
+}
+
+double HybridEmail::getNumPartsOfType(const std::string& contentType, bool inlineOnly, bool excludeAttachments) {
+  this->beginCall();
+  return getNumPartsOfType_impl(contentType, inlineOnly, excludeAttachments);
+}
+double HybridEmail::getNumPartsOfType_impl(const std::string& contentType, bool inlineOnly, bool excludeAttachments) {
+  rt::checkNoNul(contentType, "contentType");
+  return static_cast<double>(this->ck().GetNumPartsOfType(contentType.c_str(), inlineOnly, excludeAttachments));
+}
+
+std::string HybridEmail::getPlainTextBody() {
+  this->beginCall();
+  return getPlainTextBody_impl();
+}
+std::string HybridEmail::getPlainTextBody_impl() {
+  CkString _out;
+  if (!this->ck().GetPlainTextBody(_out)) throw this->fail("getPlainTextBody");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getRelatedAttr(double index, const std::string& fieldName, const std::string& attrName) {
+  this->beginCall();
+  return getRelatedAttr_impl(index, fieldName, attrName);
+}
+std::string HybridEmail::getRelatedAttr_impl(double index, const std::string& fieldName, const std::string& attrName) {
+  rt::checkNoNul(fieldName, "fieldName");
+  rt::checkNoNul(attrName, "attrName");
+  CkString _out;
+  if (!this->ck().GetRelatedAttr(rt::toInt(index, "index"), fieldName.c_str(), attrName.c_str(), _out)) throw this->fail("getRelatedAttr");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getRelatedContentID(double index) {
+  this->beginCall();
+  return getRelatedContentID_impl(index);
+}
+std::string HybridEmail::getRelatedContentID_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetRelatedContentID(rt::toInt(index, "index"), _out)) throw this->fail("getRelatedContentID");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getRelatedContentLocation(double index) {
+  this->beginCall();
+  return getRelatedContentLocation_impl(index);
+}
+std::string HybridEmail::getRelatedContentLocation_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetRelatedContentLocation(rt::toInt(index, "index"), _out)) throw this->fail("getRelatedContentLocation");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getRelatedContentType(double index) {
+  this->beginCall();
+  return getRelatedContentType_impl(index);
+}
+std::string HybridEmail::getRelatedContentType_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetRelatedContentType(rt::toInt(index, "index"), _out)) throw this->fail("getRelatedContentType");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getRelatedFilename(double index) {
+  this->beginCall();
+  return getRelatedFilename_impl(index);
+}
+std::string HybridEmail::getRelatedFilename_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetRelatedFilename(rt::toInt(index, "index"), _out)) throw this->fail("getRelatedFilename");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getRelatedString(double index, const std::string& charset) {
+  this->beginCall();
+  return getRelatedString_impl(index, charset);
+}
+std::string HybridEmail::getRelatedString_impl(double index, const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().GetRelatedString(rt::toInt(index, "index"), charset.c_str(), _out)) throw this->fail("getRelatedString");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getRelatedStringCrLf(double index, const std::string& charset) {
+  this->beginCall();
+  return getRelatedStringCrLf_impl(index, charset);
+}
+std::string HybridEmail::getRelatedStringCrLf_impl(double index, const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().GetRelatedStringCrLf(rt::toInt(index, "index"), charset.c_str(), _out)) throw this->fail("getRelatedStringCrLf");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getReplacePattern(double index) {
+  this->beginCall();
+  return getReplacePattern_impl(index);
+}
+std::string HybridEmail::getReplacePattern_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetReplacePattern(rt::toInt(index, "index"), _out)) throw this->fail("getReplacePattern");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getReplaceString(double index) {
+  this->beginCall();
+  return getReplaceString_impl(index);
+}
+std::string HybridEmail::getReplaceString_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetReplaceString(rt::toInt(index, "index"), _out)) throw this->fail("getReplaceString");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getReplaceString2(const std::string& pattern) {
+  this->beginCall();
+  return getReplaceString2_impl(pattern);
+}
+std::string HybridEmail::getReplaceString2_impl(const std::string& pattern) {
+  rt::checkNoNul(pattern, "pattern");
+  CkString _out;
+  if (!this->ck().GetReplaceString2(pattern.c_str(), _out)) throw this->fail("getReplaceString2");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getReport(double index) {
+  this->beginCall();
+  return getReport_impl(index);
+}
+std::string HybridEmail::getReport_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetReport(rt::toInt(index, "index"), _out)) throw this->fail("getReport");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getTo(double index) {
+  this->beginCall();
+  return getTo_impl(index);
+}
+std::string HybridEmail::getTo_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetTo(rt::toInt(index, "index"), _out)) throw this->fail("getTo");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getToAddr(double index) {
+  this->beginCall();
+  return getToAddr_impl(index);
+}
+std::string HybridEmail::getToAddr_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetToAddr(rt::toInt(index, "index"), _out)) throw this->fail("getToAddr");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getToName(double index) {
+  this->beginCall();
+  return getToName_impl(index);
+}
+std::string HybridEmail::getToName_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetToName(rt::toInt(index, "index"), _out)) throw this->fail("getToName");
+  return rt::stdString(_out);
+}
+
+std::string HybridEmail::getXml() {
+  this->beginCall();
+  return getXml_impl();
+}
+std::string HybridEmail::getXml_impl() {
+  CkString _out;
+  if (!this->ck().GetXml(_out)) throw this->fail("getXml");
+  return rt::stdString(_out);
+}
+
+bool HybridEmail::hasHeaderMatching(const std::string& fieldName, const std::string& valuePattern, bool caseSensitive) {
+  this->beginCall();
+  return hasHeaderMatching_impl(fieldName, valuePattern, caseSensitive);
+}
+bool HybridEmail::hasHeaderMatching_impl(const std::string& fieldName, const std::string& valuePattern, bool caseSensitive) {
+  rt::checkNoNul(fieldName, "fieldName");
+  rt::checkNoNul(valuePattern, "valuePattern");
+  return this->ck().HasHeaderMatching(fieldName.c_str(), valuePattern.c_str(), caseSensitive);
+}
+
+bool HybridEmail::hasHtmlBody() {
+  this->beginCall();
+  return hasHtmlBody_impl();
+}
+bool HybridEmail::hasHtmlBody_impl() {
+  return this->ck().HasHtmlBody();
+}
+
+bool HybridEmail::hasPlainTextBody() {
+  this->beginCall();
+  return hasPlainTextBody_impl();
+}
+bool HybridEmail::hasPlainTextBody_impl() {
+  return this->ck().HasPlainTextBody();
+}
+
+bool HybridEmail::isMultipartReport() {
+  this->beginCall();
+  return isMultipartReport_impl();
+}
+bool HybridEmail::isMultipartReport_impl() {
+  return this->ck().IsMultipartReport();
+}
+
+void HybridEmail::loadEml(const std::string& mimePath) {
+  this->beginCall();
+  loadEml_impl(mimePath);
+}
+void HybridEmail::loadEml_impl(const std::string& mimePath) {
+  rt::checkNoNul(mimePath, "mimePath");
+  if (!this->ck().LoadEml(mimePath.c_str())) throw this->fail("loadEml");
+}
+
+void HybridEmail::loadXml(const std::string& xmlPath) {
+  this->beginCall();
+  loadXml_impl(xmlPath);
+}
+void HybridEmail::loadXml_impl(const std::string& xmlPath) {
+  rt::checkNoNul(xmlPath, "xmlPath");
+  if (!this->ck().LoadXml(xmlPath.c_str())) throw this->fail("loadXml");
+}
+
+void HybridEmail::loadXmlString(const std::string& xmlStr) {
+  this->beginCall();
+  loadXmlString_impl(xmlStr);
+}
+void HybridEmail::loadXmlString_impl(const std::string& xmlStr) {
+  rt::checkNoNul(xmlStr, "xmlStr");
+  if (!this->ck().LoadXmlString(xmlStr.c_str())) throw this->fail("loadXmlString");
+}
+
+std::string HybridEmail::qEncodeString(const std::string& str, const std::string& charset) {
+  this->beginCall();
+  return qEncodeString_impl(str, charset);
+}
+std::string HybridEmail::qEncodeString_impl(const std::string& str, const std::string& charset) {
+  rt::checkNoNul(str, "str");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().QEncodeString(str.c_str(), charset.c_str(), _out)) throw this->fail("qEncodeString");
+  return rt::stdString(_out);
+}
+
+void HybridEmail::removeAttachedMessage(double idx) {
+  this->beginCall();
+  removeAttachedMessage_impl(idx);
+}
+void HybridEmail::removeAttachedMessage_impl(double idx) {
+  this->ck().RemoveAttachedMessage(rt::toInt(idx, "idx"));
+}
+
+void HybridEmail::removeAttachedMessages() {
+  this->beginCall();
+  removeAttachedMessages_impl();
+}
+void HybridEmail::removeAttachedMessages_impl() {
+  this->ck().RemoveAttachedMessages();
+}
+
+void HybridEmail::removeAttachmentPaths() {
+  this->beginCall();
+  removeAttachmentPaths_impl();
+}
+void HybridEmail::removeAttachmentPaths_impl() {
+  this->ck().RemoveAttachmentPaths();
+}
+
+void HybridEmail::removeHeaderField(const std::string& fieldName) {
+  this->beginCall();
+  removeHeaderField_impl(fieldName);
+}
+void HybridEmail::removeHeaderField_impl(const std::string& fieldName) {
+  rt::checkNoNul(fieldName, "fieldName");
+  this->ck().RemoveHeaderField(fieldName.c_str());
+}
+
+void HybridEmail::removeHtmlAlternative() {
+  this->beginCall();
+  removeHtmlAlternative_impl();
+}
+void HybridEmail::removeHtmlAlternative_impl() {
+  this->ck().RemoveHtmlAlternative();
+}
+
+void HybridEmail::removePlainTextAlternative() {
+  this->beginCall();
+  removePlainTextAlternative_impl();
+}
+void HybridEmail::removePlainTextAlternative_impl() {
+  this->ck().RemovePlainTextAlternative();
+}
+
+void HybridEmail::saveAllAttachments(const std::string& dirPath) {
+  this->beginCall();
+  saveAllAttachments_impl(dirPath);
+}
+void HybridEmail::saveAllAttachments_impl(const std::string& dirPath) {
+  rt::checkNoNul(dirPath, "dirPath");
+  if (!this->ck().SaveAllAttachments(dirPath.c_str())) throw this->fail("saveAllAttachments");
+}
+
+void HybridEmail::saveAttachedFile(double index, const std::string& dirPath) {
+  this->beginCall();
+  saveAttachedFile_impl(index, dirPath);
+}
+void HybridEmail::saveAttachedFile_impl(double index, const std::string& dirPath) {
+  rt::checkNoNul(dirPath, "dirPath");
+  if (!this->ck().SaveAttachedFile(rt::toInt(index, "index"), dirPath.c_str())) throw this->fail("saveAttachedFile");
+}
+
+void HybridEmail::saveEml(const std::string& emlFilePath) {
+  this->beginCall();
+  saveEml_impl(emlFilePath);
+}
+void HybridEmail::saveEml_impl(const std::string& emlFilePath) {
+  rt::checkNoNul(emlFilePath, "emlFilePath");
+  if (!this->ck().SaveEml(emlFilePath.c_str())) throw this->fail("saveEml");
+}
+
+void HybridEmail::saveRelatedItem(double index, const std::string& dirPath) {
+  this->beginCall();
+  saveRelatedItem_impl(index, dirPath);
+}
+void HybridEmail::saveRelatedItem_impl(double index, const std::string& dirPath) {
+  rt::checkNoNul(dirPath, "dirPath");
+  if (!this->ck().SaveRelatedItem(rt::toInt(index, "index"), dirPath.c_str())) throw this->fail("saveRelatedItem");
+}
+
+void HybridEmail::saveXml(const std::string& path) {
+  this->beginCall();
+  saveXml_impl(path);
+}
+void HybridEmail::saveXml_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SaveXml(path.c_str())) throw this->fail("saveXml");
+}
+
+void HybridEmail::setAttachmentCharset(double index, const std::string& charset) {
+  this->beginCall();
+  setAttachmentCharset_impl(index, charset);
+}
+void HybridEmail::setAttachmentCharset_impl(double index, const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().SetAttachmentCharset(rt::toInt(index, "index"), charset.c_str())) throw this->fail("setAttachmentCharset");
+}
+
+void HybridEmail::setAttachmentDisposition(double index, const std::string& disposition) {
+  this->beginCall();
+  setAttachmentDisposition_impl(index, disposition);
+}
+void HybridEmail::setAttachmentDisposition_impl(double index, const std::string& disposition) {
+  rt::checkNoNul(disposition, "disposition");
+  if (!this->ck().SetAttachmentDisposition(rt::toInt(index, "index"), disposition.c_str())) throw this->fail("setAttachmentDisposition");
+}
+
+void HybridEmail::setAttachmentFilename(double index, const std::string& filename) {
+  this->beginCall();
+  setAttachmentFilename_impl(index, filename);
+}
+void HybridEmail::setAttachmentFilename_impl(double index, const std::string& filename) {
+  rt::checkNoNul(filename, "filename");
+  if (!this->ck().SetAttachmentFilename(rt::toInt(index, "index"), filename.c_str())) throw this->fail("setAttachmentFilename");
+}
+
+void HybridEmail::setDecryptCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setDecryptCert_impl(cert);
+}
+void HybridEmail::setDecryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetDecryptCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setDecryptCert");
+}
+
+void HybridEmail::setDecryptCert2(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& key) {
+  this->beginCall();
+  setDecryptCert2_impl(cert, key);
+}
+void HybridEmail::setDecryptCert2_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& key) {
+  if (!this->ck().SetDecryptCert2(rt::implOf<HybridCert>(cert, "cert").ck(), rt::implOf<HybridPrivateKey>(key, "key").ck())) throw this->fail("setDecryptCert2");
+}
+
+void HybridEmail::setDt(const std::shared_ptr<HybridCkDateTimeSpec>& dt) {
+  this->beginCall();
+  setDt_impl(dt);
+}
+void HybridEmail::setDt_impl(const std::shared_ptr<HybridCkDateTimeSpec>& dt) {
+  if (!this->ck().SetDt(rt::implOf<HybridCkDateTime>(dt, "dt").ck())) throw this->fail("setDt");
+}
+
+void HybridEmail::setEdifactBody(const std::string& message, const std::string& name, const std::string& filename, const std::string& charset) {
+  this->beginCall();
+  setEdifactBody_impl(message, name, filename, charset);
+}
+void HybridEmail::setEdifactBody_impl(const std::string& message, const std::string& name, const std::string& filename, const std::string& charset) {
+  rt::checkNoNul(message, "message");
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(filename, "filename");
+  rt::checkNoNul(charset, "charset");
+  this->ck().SetEdifactBody(message.c_str(), name.c_str(), filename.c_str(), charset.c_str());
+}
+
+void HybridEmail::setEncryptCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setEncryptCert_impl(cert);
+}
+void HybridEmail::setEncryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetEncryptCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setEncryptCert");
+}
+
+void HybridEmail::setFromMimeText(const std::string& mimeText) {
+  this->beginCall();
+  setFromMimeText_impl(mimeText);
+}
+void HybridEmail::setFromMimeText_impl(const std::string& mimeText) {
+  rt::checkNoNul(mimeText, "mimeText");
+  if (!this->ck().SetFromMimeText(mimeText.c_str())) throw this->fail("setFromMimeText");
+}
+
+void HybridEmail::setFromXmlText(const std::string& xmlStr) {
+  this->beginCall();
+  setFromXmlText_impl(xmlStr);
+}
+void HybridEmail::setFromXmlText_impl(const std::string& xmlStr) {
+  rt::checkNoNul(xmlStr, "xmlStr");
+  if (!this->ck().SetFromXmlText(xmlStr.c_str())) throw this->fail("setFromXmlText");
+}
+
+void HybridEmail::setHtmlBody(const std::string& html) {
+  this->beginCall();
+  setHtmlBody_impl(html);
+}
+void HybridEmail::setHtmlBody_impl(const std::string& html) {
+  rt::checkNoNul(html, "html");
+  this->ck().SetHtmlBody(html.c_str());
+}
+
+void HybridEmail::setRelatedFilename(double index, const std::string& path) {
+  this->beginCall();
+  setRelatedFilename_impl(index, path);
+}
+void HybridEmail::setRelatedFilename_impl(double index, const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SetRelatedFilename(rt::toInt(index, "index"), path.c_str())) throw this->fail("setRelatedFilename");
+}
+
+void HybridEmail::setReplacePattern(const std::string& pattern, const std::string& replaceString) {
+  this->beginCall();
+  setReplacePattern_impl(pattern, replaceString);
+}
+void HybridEmail::setReplacePattern_impl(const std::string& pattern, const std::string& replaceString) {
+  rt::checkNoNul(pattern, "pattern");
+  rt::checkNoNul(replaceString, "replaceString");
+  if (!this->ck().SetReplacePattern(pattern.c_str(), replaceString.c_str())) throw this->fail("setReplacePattern");
+}
+
+void HybridEmail::setSigningCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setSigningCert_impl(cert);
+}
+void HybridEmail::setSigningCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetSigningCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setSigningCert");
+}
+
+void HybridEmail::setSigningCert2(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& key) {
+  this->beginCall();
+  setSigningCert2_impl(cert, key);
+}
+void HybridEmail::setSigningCert2_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& key) {
+  if (!this->ck().SetSigningCert2(rt::implOf<HybridCert>(cert, "cert").ck(), rt::implOf<HybridPrivateKey>(key, "key").ck())) throw this->fail("setSigningCert2");
+}
+
+void HybridEmail::setTextBody(const std::string& bodyText, const std::string& contentType) {
+  this->beginCall();
+  setTextBody_impl(bodyText, contentType);
+}
+void HybridEmail::setTextBody_impl(const std::string& bodyText, const std::string& contentType) {
+  rt::checkNoNul(bodyText, "bodyText");
+  rt::checkNoNul(contentType, "contentType");
+  this->ck().SetTextBody(bodyText.c_str(), contentType.c_str());
+}
+
+bool HybridEmail::uidlEquals(const std::shared_ptr<HybridEmailSpec>& e) {
+  this->beginCall();
+  return uidlEquals_impl(e);
+}
+bool HybridEmail::uidlEquals_impl(const std::shared_ptr<HybridEmailSpec>& e) {
+  return this->ck().UidlEquals(rt::implOf<HybridEmail>(e, "e").ck());
+}
+
+void HybridEmail::unSpamify() {
+  this->beginCall();
+  unSpamify_impl();
+}
+void HybridEmail::unSpamify_impl() {
+  this->ck().UnSpamify();
+}
+
+void HybridEmail::unpackHtml(const std::string& unpackDir, const std::string& htmlFilename, const std::string& partsSubdir) {
+  this->beginCall();
+  unpackHtml_impl(unpackDir, htmlFilename, partsSubdir);
+}
+void HybridEmail::unpackHtml_impl(const std::string& unpackDir, const std::string& htmlFilename, const std::string& partsSubdir) {
+  rt::checkNoNul(unpackDir, "unpackDir");
+  rt::checkNoNul(htmlFilename, "htmlFilename");
+  rt::checkNoNul(partsSubdir, "partsSubdir");
+  if (!this->ck().UnpackHtml(unpackDir.c_str(), htmlFilename.c_str(), partsSubdir.c_str())) throw this->fail("unpackHtml");
+}
+
+void HybridEmail::unzipAttachments() {
+  this->beginCall();
+  unzipAttachments_impl();
+}
+void HybridEmail::unzipAttachments_impl() {
+  if (!this->ck().UnzipAttachments()) throw this->fail("unzipAttachments");
+}
+
+void HybridEmail::useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  this->beginCall();
+  useCertVault_impl(vault);
+}
+void HybridEmail::useCertVault_impl(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  if (!this->ck().UseCertVault(rt::implOf<HybridXmlCertVault>(vault, "vault").ck())) throw this->fail("useCertVault");
+}
+
+void HybridEmail::zipAttachments(const std::string& zipFilename) {
+  this->beginCall();
+  zipAttachments_impl(zipFilename);
+}
+void HybridEmail::zipAttachments_impl(const std::string& zipFilename) {
+  rt::checkNoNul(zipFilename, "zipFilename");
+  if (!this->ck().ZipAttachments(zipFilename.c_str())) throw this->fail("zipAttachments");
+}
+
+std::string HybridEmail::computeGlobalKey2(const std::string& encoding, bool bFold) {
+  this->beginCall();
+  return computeGlobalKey2_impl(encoding, bFold);
+}
+std::string HybridEmail::computeGlobalKey2_impl(const std::string& encoding, bool bFold) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().ComputeGlobalKey2(encoding.c_str(), bFold, _out)) throw this->fail("computeGlobalKey2");
+  return rt::stdString(_out);
+}
+
+void HybridEmail::getMimeSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  getMimeSb_impl(sb);
+}
+void HybridEmail::getMimeSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().GetMimeSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("getMimeSb");
+}
+
+void HybridEmail::getMimeBd(const std::shared_ptr<HybridBinDataSpec>& bindat) {
+  this->beginCall();
+  getMimeBd_impl(bindat);
+}
+void HybridEmail::getMimeBd_impl(const std::shared_ptr<HybridBinDataSpec>& bindat) {
+  if (!this->ck().GetMimeBd(rt::implOf<HybridBinData>(bindat, "bindat").ck())) throw this->fail("getMimeBd");
+}
+
+void HybridEmail::setFromMimeSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  setFromMimeSb_impl(sb);
+}
+void HybridEmail::setFromMimeSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().SetFromMimeSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("setFromMimeSb");
+}
+
+void HybridEmail::setFromMimeBd(const std::shared_ptr<HybridBinDataSpec>& bindat) {
+  this->beginCall();
+  setFromMimeBd_impl(bindat);
+}
+void HybridEmail::setFromMimeBd_impl(const std::shared_ptr<HybridBinDataSpec>& bindat) {
+  if (!this->ck().SetFromMimeBd(rt::implOf<HybridBinData>(bindat, "bindat").ck())) throw this->fail("setFromMimeBd");
+}
+
+void HybridEmail::addAttachmentBd(const std::string& filename, const std::shared_ptr<HybridBinDataSpec>& binData, const std::string& contentType) {
+  this->beginCall();
+  addAttachmentBd_impl(filename, binData, contentType);
+}
+void HybridEmail::addAttachmentBd_impl(const std::string& filename, const std::shared_ptr<HybridBinDataSpec>& binData, const std::string& contentType) {
+  rt::checkNoNul(filename, "filename");
+  rt::checkNoNul(contentType, "contentType");
+  if (!this->ck().AddAttachmentBd(filename.c_str(), rt::implOf<HybridBinData>(binData, "binData").ck(), contentType.c_str())) throw this->fail("addAttachmentBd");
+}
+
+std::string HybridEmail::addRelatedBd(const std::string& filename, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  return addRelatedBd_impl(filename, binData);
+}
+std::string HybridEmail::addRelatedBd_impl(const std::string& filename, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  rt::checkNoNul(filename, "filename");
+  CkString _out;
+  if (!this->ck().AddRelatedBd(filename.c_str(), rt::implOf<HybridBinData>(binData, "binData").ck(), _out)) throw this->fail("addRelatedBd");
+  return rt::stdString(_out);
+}
+
+void HybridEmail::addRelatedBd2(const std::shared_ptr<HybridBinDataSpec>& binData, const std::string& fileNameInHtml) {
+  this->beginCall();
+  addRelatedBd2_impl(binData, fileNameInHtml);
+}
+void HybridEmail::addRelatedBd2_impl(const std::shared_ptr<HybridBinDataSpec>& binData, const std::string& fileNameInHtml) {
+  rt::checkNoNul(fileNameInHtml, "fileNameInHtml");
+  if (!this->ck().AddRelatedBd2(rt::implOf<HybridBinData>(binData, "binData").ck(), fileNameInHtml.c_str())) throw this->fail("addRelatedBd2");
+}
+
+void HybridEmail::getAttachmentBd(double index, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  getAttachmentBd_impl(index, binData);
+}
+void HybridEmail::getAttachmentBd_impl(double index, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().GetAttachmentBd(rt::toInt(index, "index"), rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("getAttachmentBd");
+}
+
+void HybridEmail::getAlternativeBodyBd(double index, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  getAlternativeBodyBd_impl(index, binData);
+}
+void HybridEmail::getAlternativeBodyBd_impl(double index, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().GetAlternativeBodyBd(rt::toInt(index, "index"), rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("getAlternativeBodyBd");
+}
+
+void HybridEmail::applyFixups(const std::string& fixups) {
+  this->beginCall();
+  applyFixups_impl(fixups);
+}
+void HybridEmail::applyFixups_impl(const std::string& fixups) {
+  rt::checkNoNul(fixups, "fixups");
+  if (!this->ck().ApplyFixups(fixups.c_str())) throw this->fail("applyFixups");
+}
+
+void HybridEmail::clear() {
+  this->beginCall();
+  clear_impl();
+}
+void HybridEmail::clear_impl() {
+  this->ck().Clear();
+}
+
+void HybridEmail::convertInlineImages() {
+  this->beginCall();
+  convertInlineImages_impl();
+}
+void HybridEmail::convertInlineImages_impl() {
+  if (!this->ck().ConvertInlineImages()) throw this->fail("convertInlineImages");
+}
+
+void HybridEmail::attachEmail(const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  attachEmail_impl(email);
+}
+void HybridEmail::attachEmail_impl(const std::shared_ptr<HybridEmailSpec>& email) {
+  if (!this->ck().AttachEmail(rt::implOf<HybridEmail>(email, "email").ck())) throw this->fail("attachEmail");
+}
+
+std::string HybridEmail::getNthContentType(double index, const std::string& contentType, bool inlineOnly, bool excludeAttachments) {
+  this->beginCall();
+  return getNthContentType_impl(index, contentType, inlineOnly, excludeAttachments);
+}
+std::string HybridEmail::getNthContentType_impl(double index, const std::string& contentType, bool inlineOnly, bool excludeAttachments) {
+  rt::checkNoNul(contentType, "contentType");
+  CkString _out;
+  if (!this->ck().GetNthContentType(rt::toInt(index, "index"), contentType.c_str(), inlineOnly, excludeAttachments, _out)) throw this->fail("getNthContentType");
+  return rt::stdString(_out);
+}
+
+void HybridEmail::getNthBinaryPartOfTypeBd(double index, const std::string& contentType, bool inlineOnly, bool excludeAttachments, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  getNthBinaryPartOfTypeBd_impl(index, contentType, inlineOnly, excludeAttachments, bd);
+}
+void HybridEmail::getNthBinaryPartOfTypeBd_impl(double index, const std::string& contentType, bool inlineOnly, bool excludeAttachments, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(contentType, "contentType");
+  if (!this->ck().GetNthBinaryPartOfTypeBd(rt::toInt(index, "index"), contentType.c_str(), inlineOnly, excludeAttachments, rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("getNthBinaryPartOfTypeBd");
+}
+
+std::string HybridEmail::getRelatedHeader(double index, const std::string& fieldName) {
+  this->beginCall();
+  return getRelatedHeader_impl(index, fieldName);
+}
+std::string HybridEmail::getRelatedHeader_impl(double index, const std::string& fieldName) {
+  rt::checkNoNul(fieldName, "fieldName");
+  CkString _out;
+  if (!this->ck().GetRelatedHeader(rt::toInt(index, "index"), fieldName.c_str(), _out)) throw this->fail("getRelatedHeader");
+  return rt::stdString(_out);
+}
+
+void HybridEmail::getHtmlBodySb(bool inlineImageData, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  getHtmlBodySb_impl(inlineImageData, sb);
+}
+void HybridEmail::getHtmlBodySb_impl(bool inlineImageData, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().GetHtmlBodySb(inlineImageData, rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("getHtmlBodySb");
+}
+
+void HybridEmail::lastDecryptCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  lastDecryptCert_impl(cert);
+}
+void HybridEmail::lastDecryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().LastDecryptCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("lastDecryptCert");
+}
+
+void HybridEmail::lastSignerCert(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  lastSignerCert_impl(index, cert);
+}
+void HybridEmail::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 HybridEmail::makeCopy(const std::shared_ptr<HybridEmailSpec>& destEmail) {
+  this->beginCall();
+  makeCopy_impl(destEmail);
+}
+void HybridEmail::makeCopy_impl(const std::shared_ptr<HybridEmailSpec>& destEmail) {
+  if (!this->ck().MakeCopy(rt::implOf<HybridEmail>(destEmail, "destEmail").ck())) throw this->fail("makeCopy");
+}
+
+void HybridEmail::toDsn(const std::string& explanation, const std::string& statusFields, bool headerOnly, const std::shared_ptr<HybridEmailSpec>& dsnEmail) {
+  this->beginCall();
+  toDsn_impl(explanation, statusFields, headerOnly, dsnEmail);
+}
+void HybridEmail::toDsn_impl(const std::string& explanation, const std::string& statusFields, bool headerOnly, const std::shared_ptr<HybridEmailSpec>& dsnEmail) {
+  rt::checkNoNul(explanation, "explanation");
+  rt::checkNoNul(statusFields, "statusFields");
+  if (!this->ck().ToDsn(explanation.c_str(), statusFields.c_str(), headerOnly, rt::implOf<HybridEmail>(dsnEmail, "dsnEmail").ck())) throw this->fail("toDsn");
+}
+
+void HybridEmail::toForward(const std::shared_ptr<HybridEmailSpec>& fwdEmail) {
+  this->beginCall();
+  toForward_impl(fwdEmail);
+}
+void HybridEmail::toForward_impl(const std::shared_ptr<HybridEmailSpec>& fwdEmail) {
+  if (!this->ck().ToForward(rt::implOf<HybridEmail>(fwdEmail, "fwdEmail").ck())) throw this->fail("toForward");
+}
+
+void HybridEmail::toMdn(const std::string& message, const std::string& statusFields, bool headerOnly, const std::shared_ptr<HybridEmailSpec>& mdn) {
+  this->beginCall();
+  toMdn_impl(message, statusFields, headerOnly, mdn);
+}
+void HybridEmail::toMdn_impl(const std::string& message, const std::string& statusFields, bool headerOnly, const std::shared_ptr<HybridEmailSpec>& mdn) {
+  rt::checkNoNul(message, "message");
+  rt::checkNoNul(statusFields, "statusFields");
+  if (!this->ck().ToMdn(message.c_str(), statusFields.c_str(), headerOnly, rt::implOf<HybridEmail>(mdn, "mdn").ck())) throw this->fail("toMdn");
+}
+
+void HybridEmail::toReply(const std::shared_ptr<HybridEmailSpec>& reply) {
+  this->beginCall();
+  toReply_impl(reply);
+}
+void HybridEmail::toReply_impl(const std::shared_ptr<HybridEmailSpec>& reply) {
+  if (!this->ck().ToReply(rt::implOf<HybridEmail>(reply, "reply").ck())) throw this->fail("toReply");
+}
+
+void HybridEmail::getAttachedEmail(double index, const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  getAttachedEmail_impl(index, email);
+}
+void HybridEmail::getAttachedEmail_impl(double index, const std::shared_ptr<HybridEmailSpec>& email) {
+  if (!this->ck().GetAttachedEmail(rt::toInt(index, "index"), rt::implOf<HybridEmail>(email, "email").ck())) throw this->fail("getAttachedEmail");
+}
+
+void HybridEmail::getDigestEmail(double index, const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  getDigestEmail_impl(index, email);
+}
+void HybridEmail::getDigestEmail_impl(double index, const std::shared_ptr<HybridEmailSpec>& email) {
+  if (!this->ck().GetDigestEmail(rt::toInt(index, "index"), rt::implOf<HybridEmail>(email, "email").ck())) throw this->fail("getDigestEmail");
+}
+
+void HybridEmail::getDsnInfo(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getDsnInfo_impl(json);
+}
+void HybridEmail::getDsnInfo_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().GetDsnInfo(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("getDsnInfo");
+}
+
+void HybridEmail::linkedDomains(const std::shared_ptr<HybridStringTableSpec>& domains) {
+  this->beginCall();
+  linkedDomains_impl(domains);
+}
+void HybridEmail::linkedDomains_impl(const std::shared_ptr<HybridStringTableSpec>& domains) {
+  if (!this->ck().LinkedDomains(rt::implOf<HybridStringTable>(domains, "domains").ck())) throw this->fail("linkedDomains");
+}
+
+void HybridEmail::addPfxSourceBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) {
+  this->beginCall();
+  addPfxSourceBd_impl(bd, password);
+}
+void HybridEmail::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 HybridEmail::setBodyBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& contentType, const std::string& disposition, const std::string& filename) {
+  this->beginCall();
+  setBodyBd_impl(bd, contentType, disposition, filename);
+}
+void HybridEmail::setBodyBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& contentType, const std::string& disposition, const std::string& filename) {
+  rt::checkNoNul(contentType, "contentType");
+  rt::checkNoNul(disposition, "disposition");
+  rt::checkNoNul(filename, "filename");
+  if (!this->ck().SetBodyBd(rt::implOf<HybridBinData>(bd, "bd").ck(), contentType.c_str(), disposition.c_str(), filename.c_str())) throw this->fail("setBodyBd");
+}
+
+} // namespace margelo::nitro::chilkat