@chilkat/react-native 11.6.1

package/cpp/HybridMailMan.cpp

@@ -0,0 +1,1853 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridMailMan.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCert.hpp"
+#include "HybridEmail.hpp"
+#include "HybridEmailBundle.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridPrivateKey.hpp"
+#include "HybridSecureString.hpp"
+#include "HybridSocket.hpp"
+#include "HybridSsh.hpp"
+#include "HybridSshKey.hpp"
+#include "HybridStringArray.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridStringTable.hpp"
+#include "HybridXmlCertVault.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+#include <CkMailManProgress.h>
+
+namespace margelo::nitro::chilkat {
+
+HybridMailMan::HybridMailMan()
+    : HybridObject(HybridMailManSpec::TAG), ChilkatObject<CkMailMan>("MailMan", CkMailMan::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridMailMan::HybridMailMan(CkMailMan* owned)
+    : HybridObject(HybridMailManSpec::TAG), ChilkatObject<CkMailMan>("MailMan", owned) {
+  init();
+}
+
+void HybridMailMan::init() {
+  this->installProgress<ProgressAdapter<CkMailManProgress>>();
+}
+
+void HybridMailMan::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridMailMan::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMailMan::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMailMan::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMailMan::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMailMan::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridMailMan::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridMailMan::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridMailMan::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridMailMan::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridMailMan::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridMailMan::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+bool HybridMailMan::getAllOrNone() {
+  this->beginCall();
+  return this->ck().get_AllOrNone();
+}
+void HybridMailMan::setAllOrNone(bool value) {
+  this->beginCall();
+  this->ck().put_AllOrNone(value);
+}
+bool HybridMailMan::getAutoFix() {
+  this->beginCall();
+  return this->ck().get_AutoFix();
+}
+void HybridMailMan::setAutoFix(bool value) {
+  this->beginCall();
+  this->ck().put_AutoFix(value);
+}
+bool HybridMailMan::getAutoGenMessageId() {
+  this->beginCall();
+  return this->ck().get_AutoGenMessageId();
+}
+void HybridMailMan::setAutoGenMessageId(bool value) {
+  this->beginCall();
+  this->ck().put_AutoGenMessageId(value);
+}
+bool HybridMailMan::getAutoSmtpRset() {
+  this->beginCall();
+  return this->ck().get_AutoSmtpRset();
+}
+void HybridMailMan::setAutoSmtpRset(bool value) {
+  this->beginCall();
+  this->ck().put_AutoSmtpRset(value);
+}
+bool HybridMailMan::getAutoUnwrapSecurity() {
+  this->beginCall();
+  return this->ck().get_AutoUnwrapSecurity();
+}
+void HybridMailMan::setAutoUnwrapSecurity(bool value) {
+  this->beginCall();
+  this->ck().put_AutoUnwrapSecurity(value);
+}
+std::string HybridMailMan::getClientIpAddress() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ClientIpAddress(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setClientIpAddress(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "clientIpAddress");
+  this->ck().put_ClientIpAddress(value.c_str());
+}
+double HybridMailMan::getConnectFailReason() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectFailReason());
+}
+double HybridMailMan::getConnectTimeout() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectTimeout());
+}
+void HybridMailMan::setConnectTimeout(double value) {
+  this->beginCall();
+  this->ck().put_ConnectTimeout(rt::toInt(value, "connectTimeout"));
+}
+std::string HybridMailMan::getDsnEnvid() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DsnEnvid(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setDsnEnvid(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "dsnEnvid");
+  this->ck().put_DsnEnvid(value.c_str());
+}
+std::string HybridMailMan::getDsnNotify() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DsnNotify(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setDsnNotify(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "dsnNotify");
+  this->ck().put_DsnNotify(value.c_str());
+}
+std::string HybridMailMan::getDsnRet() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DsnRet(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setDsnRet(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "dsnRet");
+  this->ck().put_DsnRet(value.c_str());
+}
+bool HybridMailMan::getEmbedCertChain() {
+  this->beginCall();
+  return this->ck().get_EmbedCertChain();
+}
+void HybridMailMan::setEmbedCertChain(bool value) {
+  this->beginCall();
+  this->ck().put_EmbedCertChain(value);
+}
+std::string HybridMailMan::getFilter() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Filter(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setFilter(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "filter");
+  this->ck().put_Filter(value.c_str());
+}
+double HybridMailMan::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridMailMan::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+std::string HybridMailMan::getHeloHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HeloHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setHeloHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "heloHostname");
+  this->ck().put_HeloHostname(value.c_str());
+}
+std::string HybridMailMan::getHttpProxyAuthMethod() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyAuthMethod(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setHttpProxyAuthMethod(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyAuthMethod");
+  this->ck().put_HttpProxyAuthMethod(value.c_str());
+}
+std::string HybridMailMan::getHttpProxyDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyDomain(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setHttpProxyDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyDomain");
+  this->ck().put_HttpProxyDomain(value.c_str());
+}
+std::string HybridMailMan::getHttpProxyHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setHttpProxyHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyHostname");
+  this->ck().put_HttpProxyHostname(value.c_str());
+}
+std::string HybridMailMan::getHttpProxyPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setHttpProxyPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyPassword");
+  this->ck().put_HttpProxyPassword(value.c_str());
+}
+double HybridMailMan::getHttpProxyPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HttpProxyPort());
+}
+void HybridMailMan::setHttpProxyPort(double value) {
+  this->beginCall();
+  this->ck().put_HttpProxyPort(rt::toInt(value, "httpProxyPort"));
+}
+std::string HybridMailMan::getHttpProxyUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setHttpProxyUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyUsername");
+  this->ck().put_HttpProxyUsername(value.c_str());
+}
+bool HybridMailMan::getImmediateDelete() {
+  this->beginCall();
+  return this->ck().get_ImmediateDelete();
+}
+void HybridMailMan::setImmediateDelete(bool value) {
+  this->beginCall();
+  this->ck().put_ImmediateDelete(value);
+}
+bool HybridMailMan::getIncludeRootCert() {
+  this->beginCall();
+  return this->ck().get_IncludeRootCert();
+}
+void HybridMailMan::setIncludeRootCert(bool value) {
+  this->beginCall();
+  this->ck().put_IncludeRootCert(value);
+}
+bool HybridMailMan::getIsPop3Connected() {
+  this->beginCall();
+  return this->ck().get_IsPop3Connected();
+}
+bool HybridMailMan::getIsSmtpConnected() {
+  this->beginCall();
+  return this->ck().get_IsSmtpConnected();
+}
+double HybridMailMan::getLastSmtpStatus() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_LastSmtpStatus());
+}
+std::string HybridMailMan::getLogMailReceivedFilename() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LogMailReceivedFilename(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setLogMailReceivedFilename(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "logMailReceivedFilename");
+  this->ck().put_LogMailReceivedFilename(value.c_str());
+}
+std::string HybridMailMan::getLogMailSentFilename() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LogMailSentFilename(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setLogMailSentFilename(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "logMailSentFilename");
+  this->ck().put_LogMailSentFilename(value.c_str());
+}
+std::string HybridMailMan::getMailHost() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_MailHost(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setMailHost(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "mailHost");
+  this->ck().put_MailHost(value.c_str());
+}
+double HybridMailMan::getMailPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_MailPort());
+}
+void HybridMailMan::setMailPort(double value) {
+  this->beginCall();
+  this->ck().put_MailPort(rt::toInt(value, "mailPort"));
+}
+double HybridMailMan::getMaxCount() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_MaxCount());
+}
+void HybridMailMan::setMaxCount(double value) {
+  this->beginCall();
+  this->ck().put_MaxCount(rt::toInt(value, "maxCount"));
+}
+std::string HybridMailMan::getOAuth2AccessToken() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OAuth2AccessToken(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setOAuth2AccessToken(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oAuth2AccessToken");
+  this->ck().put_OAuth2AccessToken(value.c_str());
+}
+bool HybridMailMan::getOpaqueSigning() {
+  this->beginCall();
+  return this->ck().get_OpaqueSigning();
+}
+void HybridMailMan::setOpaqueSigning(bool value) {
+  this->beginCall();
+  this->ck().put_OpaqueSigning(value);
+}
+std::string HybridMailMan::getP7mEncryptAttachFilename() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_P7mEncryptAttachFilename(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setP7mEncryptAttachFilename(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "p7mEncryptAttachFilename");
+  this->ck().put_P7mEncryptAttachFilename(value.c_str());
+}
+std::string HybridMailMan::getP7mSigAttachFilename() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_P7mSigAttachFilename(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setP7mSigAttachFilename(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "p7mSigAttachFilename");
+  this->ck().put_P7mSigAttachFilename(value.c_str());
+}
+std::string HybridMailMan::getP7sSigAttachFilename() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_P7sSigAttachFilename(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setP7sSigAttachFilename(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "p7sSigAttachFilename");
+  this->ck().put_P7sSigAttachFilename(value.c_str());
+}
+double HybridMailMan::getPercentDoneScale() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_PercentDoneScale());
+}
+void HybridMailMan::setPercentDoneScale(double value) {
+  this->beginCall();
+  this->ck().put_PercentDoneScale(rt::toInt(value, "percentDoneScale"));
+}
+bool HybridMailMan::getPop3SPA() {
+  this->beginCall();
+  return this->ck().get_Pop3SPA();
+}
+void HybridMailMan::setPop3SPA(bool value) {
+  this->beginCall();
+  this->ck().put_Pop3SPA(value);
+}
+double HybridMailMan::getPop3SessionId() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Pop3SessionId());
+}
+std::string HybridMailMan::getPop3SessionLog() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Pop3SessionLog(_s);
+  return rt::stdString(_s);
+}
+bool HybridMailMan::getPop3SslServerCertVerified() {
+  this->beginCall();
+  return this->ck().get_Pop3SslServerCertVerified();
+}
+bool HybridMailMan::getPop3Stls() {
+  this->beginCall();
+  return this->ck().get_Pop3Stls();
+}
+void HybridMailMan::setPop3Stls(bool value) {
+  this->beginCall();
+  this->ck().put_Pop3Stls(value);
+}
+std::string HybridMailMan::getPopPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_PopPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setPopPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "popPassword");
+  this->ck().put_PopPassword(value.c_str());
+}
+std::string HybridMailMan::getPopPasswordBase64() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_PopPasswordBase64(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setPopPasswordBase64(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "popPasswordBase64");
+  this->ck().put_PopPasswordBase64(value.c_str());
+}
+bool HybridMailMan::getPopSsl() {
+  this->beginCall();
+  return this->ck().get_PopSsl();
+}
+void HybridMailMan::setPopSsl(bool value) {
+  this->beginCall();
+  this->ck().put_PopSsl(value);
+}
+std::string HybridMailMan::getPopUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_PopUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setPopUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "popUsername");
+  this->ck().put_PopUsername(value.c_str());
+}
+bool HybridMailMan::getPreferIpv6() {
+  this->beginCall();
+  return this->ck().get_PreferIpv6();
+}
+void HybridMailMan::setPreferIpv6(bool value) {
+  this->beginCall();
+  this->ck().put_PreferIpv6(value);
+}
+double HybridMailMan::getReadTimeout() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ReadTimeout());
+}
+void HybridMailMan::setReadTimeout(double value) {
+  this->beginCall();
+  this->ck().put_ReadTimeout(rt::toInt(value, "readTimeout"));
+}
+bool HybridMailMan::getRequireSslCertVerify() {
+  this->beginCall();
+  return this->ck().get_RequireSslCertVerify();
+}
+void HybridMailMan::setRequireSslCertVerify(bool value) {
+  this->beginCall();
+  this->ck().put_RequireSslCertVerify(value);
+}
+bool HybridMailMan::getResetDateOnLoad() {
+  this->beginCall();
+  return this->ck().get_ResetDateOnLoad();
+}
+void HybridMailMan::setResetDateOnLoad(bool value) {
+  this->beginCall();
+  this->ck().put_ResetDateOnLoad(value);
+}
+double HybridMailMan::getSendBufferSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SendBufferSize());
+}
+void HybridMailMan::setSendBufferSize(double value) {
+  this->beginCall();
+  this->ck().put_SendBufferSize(rt::toInt(value, "sendBufferSize"));
+}
+double HybridMailMan::getSizeLimit() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SizeLimit());
+}
+void HybridMailMan::setSizeLimit(double value) {
+  this->beginCall();
+  this->ck().put_SizeLimit(rt::toInt(value, "sizeLimit"));
+}
+std::string HybridMailMan::getSmtpAuthMethod() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SmtpAuthMethod(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setSmtpAuthMethod(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "smtpAuthMethod");
+  this->ck().put_SmtpAuthMethod(value.c_str());
+}
+std::string HybridMailMan::getSmtpFailReason() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SmtpFailReason(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMailMan::getSmtpHost() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SmtpHost(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setSmtpHost(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "smtpHost");
+  this->ck().put_SmtpHost(value.c_str());
+}
+std::string HybridMailMan::getSmtpLoginDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SmtpLoginDomain(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setSmtpLoginDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "smtpLoginDomain");
+  this->ck().put_SmtpLoginDomain(value.c_str());
+}
+std::string HybridMailMan::getSmtpPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SmtpPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setSmtpPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "smtpPassword");
+  this->ck().put_SmtpPassword(value.c_str());
+}
+bool HybridMailMan::getSmtpPipelining() {
+  this->beginCall();
+  return this->ck().get_SmtpPipelining();
+}
+void HybridMailMan::setSmtpPipelining(bool value) {
+  this->beginCall();
+  this->ck().put_SmtpPipelining(value);
+}
+double HybridMailMan::getSmtpPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SmtpPort());
+}
+void HybridMailMan::setSmtpPort(double value) {
+  this->beginCall();
+  this->ck().put_SmtpPort(rt::toInt(value, "smtpPort"));
+}
+std::string HybridMailMan::getSmtpSessionLog() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SmtpSessionLog(_s);
+  return rt::stdString(_s);
+}
+bool HybridMailMan::getSmtpSsl() {
+  this->beginCall();
+  return this->ck().get_SmtpSsl();
+}
+void HybridMailMan::setSmtpSsl(bool value) {
+  this->beginCall();
+  this->ck().put_SmtpSsl(value);
+}
+bool HybridMailMan::getSmtpSslServerCertVerified() {
+  this->beginCall();
+  return this->ck().get_SmtpSslServerCertVerified();
+}
+std::string HybridMailMan::getSmtpUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SmtpUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setSmtpUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "smtpUsername");
+  this->ck().put_SmtpUsername(value.c_str());
+}
+double HybridMailMan::getSoRcvBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoRcvBuf());
+}
+void HybridMailMan::setSoRcvBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoRcvBuf(rt::toInt(value, "soRcvBuf"));
+}
+double HybridMailMan::getSoSndBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoSndBuf());
+}
+void HybridMailMan::setSoSndBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoSndBuf(rt::toInt(value, "soSndBuf"));
+}
+std::string HybridMailMan::getSocksHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setSocksHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksHostname");
+  this->ck().put_SocksHostname(value.c_str());
+}
+std::string HybridMailMan::getSocksPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setSocksPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksPassword");
+  this->ck().put_SocksPassword(value.c_str());
+}
+double HybridMailMan::getSocksPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksPort());
+}
+void HybridMailMan::setSocksPort(double value) {
+  this->beginCall();
+  this->ck().put_SocksPort(rt::toInt(value, "socksPort"));
+}
+std::string HybridMailMan::getSocksUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setSocksUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksUsername");
+  this->ck().put_SocksUsername(value.c_str());
+}
+double HybridMailMan::getSocksVersion() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksVersion());
+}
+void HybridMailMan::setSocksVersion(double value) {
+  this->beginCall();
+  this->ck().put_SocksVersion(rt::toInt(value, "socksVersion"));
+}
+std::string HybridMailMan::getSslAllowedCiphers() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SslAllowedCiphers(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setSslAllowedCiphers(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sslAllowedCiphers");
+  this->ck().put_SslAllowedCiphers(value.c_str());
+}
+std::string HybridMailMan::getSslProtocol() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SslProtocol(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setSslProtocol(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sslProtocol");
+  this->ck().put_SslProtocol(value.c_str());
+}
+bool HybridMailMan::getStartTLS() {
+  this->beginCall();
+  return this->ck().get_StartTLS();
+}
+void HybridMailMan::setStartTLS(bool value) {
+  this->beginCall();
+  this->ck().put_StartTLS(value);
+}
+std::string HybridMailMan::getTlsCipherSuite() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsCipherSuite(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMailMan::getTlsPinSet() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsPinSet(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setTlsPinSet(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "tlsPinSet");
+  this->ck().put_TlsPinSet(value.c_str());
+}
+std::string HybridMailMan::getTlsVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsVersion(_s);
+  return rt::stdString(_s);
+}
+bool HybridMailMan::getUseApop() {
+  this->beginCall();
+  return this->ck().get_UseApop();
+}
+void HybridMailMan::setUseApop(bool value) {
+  this->beginCall();
+  this->ck().put_UseApop(value);
+}
+bool HybridMailMan::getStartTLSifPossible() {
+  this->beginCall();
+  return this->ck().get_StartTLSifPossible();
+}
+void HybridMailMan::setStartTLSifPossible(bool value) {
+  this->beginCall();
+  this->ck().put_StartTLSifPossible(value);
+}
+std::string HybridMailMan::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+std::string HybridMailMan::getLastSmtpStatusMsg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastSmtpStatusMsg(_s);
+  return rt::stdString(_s);
+}
+bool HybridMailMan::getPop3StlsIfPossible() {
+  this->beginCall();
+  return this->ck().get_Pop3StlsIfPossible();
+}
+void HybridMailMan::setPop3StlsIfPossible(bool value) {
+  this->beginCall();
+  this->ck().put_Pop3StlsIfPossible(value);
+}
+std::string HybridMailMan::getSmtpMailFrom() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SmtpMailFrom(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setSmtpMailFrom(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "smtpMailFrom");
+  this->ck().put_SmtpMailFrom(value.c_str());
+}
+bool HybridMailMan::getEnableSecrets() {
+  this->beginCall();
+  return this->ck().get_EnableSecrets();
+}
+void HybridMailMan::setEnableSecrets(bool value) {
+  this->beginCall();
+  this->ck().put_EnableSecrets(value);
+}
+bool HybridMailMan::getRequireHostnameMatch() {
+  this->beginCall();
+  return this->ck().get_RequireHostnameMatch();
+}
+void HybridMailMan::setRequireHostnameMatch(bool value) {
+  this->beginCall();
+  this->ck().put_RequireHostnameMatch(value);
+}
+std::string HybridMailMan::getSniHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SniHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridMailMan::setSniHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sniHostname");
+  this->ck().put_SniHostname(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridMailMan::addPfxSourceFile(const std::string& pfxFilePath, const std::string& password) {
+  this->beginCall();
+  addPfxSourceFile_impl(pfxFilePath, password);
+}
+void HybridMailMan::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");
+}
+
+double HybridMailMan::checkMail() {
+  this->beginCall();
+  return checkMail_impl();
+}
+double HybridMailMan::checkMail_impl() {
+  return static_cast<double>(this->ck().CheckMail());
+}
+std::shared_ptr<Promise<double>> HybridMailMan::checkMailAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("MailMan.checkMailAsync", std::move(_parts), [_self]() {
+    return _self->checkMail_impl();
+  });
+}
+
+void HybridMailMan::clearPop3SessionLog() {
+  this->beginCall();
+  clearPop3SessionLog_impl();
+}
+void HybridMailMan::clearPop3SessionLog_impl() {
+  this->ck().ClearPop3SessionLog();
+}
+
+void HybridMailMan::clearSmtpSessionLog() {
+  this->beginCall();
+  clearSmtpSessionLog_impl();
+}
+void HybridMailMan::clearSmtpSessionLog_impl() {
+  this->ck().ClearSmtpSessionLog();
+}
+
+void HybridMailMan::closeSmtpConnection() {
+  this->beginCall();
+  closeSmtpConnection_impl();
+}
+void HybridMailMan::closeSmtpConnection_impl() {
+  if (!this->ck().CloseSmtpConnection()) throw this->fail("closeSmtpConnection");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::closeSmtpConnectionAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.closeSmtpConnectionAsync", std::move(_parts), [_self]() {
+    _self->closeSmtpConnection_impl();
+  });
+}
+
+void HybridMailMan::deleteBundle(const std::shared_ptr<HybridEmailBundleSpec>& emailBundle) {
+  this->beginCall();
+  deleteBundle_impl(emailBundle);
+}
+void HybridMailMan::deleteBundle_impl(const std::shared_ptr<HybridEmailBundleSpec>& emailBundle) {
+  if (!this->ck().DeleteBundle(rt::implOf<HybridEmailBundle>(emailBundle, "emailBundle").ck())) throw this->fail("deleteBundle");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::deleteBundleAsync(const std::shared_ptr<HybridEmailBundleSpec>& emailBundle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(emailBundle);
+  return rt::runAsync<void>("MailMan.deleteBundleAsync", std::move(_parts), [_self, emailBundle]() {
+    _self->deleteBundle_impl(emailBundle);
+  });
+}
+
+void HybridMailMan::deleteByMsgnum(double msgnum) {
+  this->beginCall();
+  deleteByMsgnum_impl(msgnum);
+}
+void HybridMailMan::deleteByMsgnum_impl(double msgnum) {
+  if (!this->ck().DeleteByMsgnum(rt::toInt(msgnum, "msgnum"))) throw this->fail("deleteByMsgnum");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::deleteByMsgnumAsync(double msgnum) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.deleteByMsgnumAsync", std::move(_parts), [_self, msgnum]() {
+    _self->deleteByMsgnum_impl(msgnum);
+  });
+}
+
+void HybridMailMan::deleteByUidl(const std::string& uidl) {
+  this->beginCall();
+  deleteByUidl_impl(uidl);
+}
+void HybridMailMan::deleteByUidl_impl(const std::string& uidl) {
+  rt::checkNoNul(uidl, "uidl");
+  if (!this->ck().DeleteByUidl(uidl.c_str())) throw this->fail("deleteByUidl");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::deleteByUidlAsync(const std::string& uidl) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.deleteByUidlAsync", std::move(_parts), [_self, uidl]() {
+    _self->deleteByUidl_impl(uidl);
+  });
+}
+
+void HybridMailMan::deleteEmail(const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  deleteEmail_impl(email);
+}
+void HybridMailMan::deleteEmail_impl(const std::shared_ptr<HybridEmailSpec>& email) {
+  if (!this->ck().DeleteEmail(rt::implOf<HybridEmail>(email, "email").ck())) throw this->fail("deleteEmail");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::deleteEmailAsync(const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(email);
+  return rt::runAsync<void>("MailMan.deleteEmailAsync", std::move(_parts), [_self, email]() {
+    _self->deleteEmail_impl(email);
+  });
+}
+
+double HybridMailMan::getMailboxCount() {
+  this->beginCall();
+  return getMailboxCount_impl();
+}
+double HybridMailMan::getMailboxCount_impl() {
+  return static_cast<double>(this->ck().GetMailboxCount());
+}
+std::shared_ptr<Promise<double>> HybridMailMan::getMailboxCountAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("MailMan.getMailboxCountAsync", std::move(_parts), [_self]() {
+    return _self->getMailboxCount_impl();
+  });
+}
+
+std::string HybridMailMan::getMailboxInfoXml() {
+  this->beginCall();
+  return getMailboxInfoXml_impl();
+}
+std::string HybridMailMan::getMailboxInfoXml_impl() {
+  CkString _out;
+  if (!this->ck().GetMailboxInfoXml(_out)) throw this->fail("getMailboxInfoXml");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridMailMan::getMailboxInfoXmlAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("MailMan.getMailboxInfoXmlAsync", std::move(_parts), [_self]() {
+    return _self->getMailboxInfoXml_impl();
+  });
+}
+
+double HybridMailMan::getMailboxSize() {
+  this->beginCall();
+  return getMailboxSize_impl();
+}
+double HybridMailMan::getMailboxSize_impl() {
+  return static_cast<double>(this->ck().GetMailboxSize());
+}
+std::shared_ptr<Promise<double>> HybridMailMan::getMailboxSizeAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("MailMan.getMailboxSizeAsync", std::move(_parts), [_self]() {
+    return _self->getMailboxSize_impl();
+  });
+}
+
+double HybridMailMan::getSizeByUidl(const std::string& uidl) {
+  this->beginCall();
+  return getSizeByUidl_impl(uidl);
+}
+double HybridMailMan::getSizeByUidl_impl(const std::string& uidl) {
+  rt::checkNoNul(uidl, "uidl");
+  return static_cast<double>(this->ck().GetSizeByUidl(uidl.c_str()));
+}
+std::shared_ptr<Promise<double>> HybridMailMan::getSizeByUidlAsync(const std::string& uidl) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("MailMan.getSizeByUidlAsync", std::move(_parts), [_self, uidl]() {
+    return _self->getSizeByUidl_impl(uidl);
+  });
+}
+
+bool HybridMailMan::isSmtpDsnCapable() {
+  this->beginCall();
+  return isSmtpDsnCapable_impl();
+}
+bool HybridMailMan::isSmtpDsnCapable_impl() {
+  return this->ck().IsSmtpDsnCapable();
+}
+std::shared_ptr<Promise<bool>> HybridMailMan::isSmtpDsnCapableAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<bool>("MailMan.isSmtpDsnCapableAsync", std::move(_parts), [_self]() {
+    return _self->isSmtpDsnCapable_impl();
+  });
+}
+
+void HybridMailMan::openSmtpConnection() {
+  this->beginCall();
+  openSmtpConnection_impl();
+}
+void HybridMailMan::openSmtpConnection_impl() {
+  if (!this->ck().OpenSmtpConnection()) throw this->fail("openSmtpConnection");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::openSmtpConnectionAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.openSmtpConnectionAsync", std::move(_parts), [_self]() {
+    _self->openSmtpConnection_impl();
+  });
+}
+
+void HybridMailMan::pop3Authenticate() {
+  this->beginCall();
+  pop3Authenticate_impl();
+}
+void HybridMailMan::pop3Authenticate_impl() {
+  if (!this->ck().Pop3Authenticate()) throw this->fail("pop3Authenticate");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::pop3AuthenticateAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.pop3AuthenticateAsync", std::move(_parts), [_self]() {
+    _self->pop3Authenticate_impl();
+  });
+}
+
+void HybridMailMan::pop3BeginSession() {
+  this->beginCall();
+  pop3BeginSession_impl();
+}
+void HybridMailMan::pop3BeginSession_impl() {
+  if (!this->ck().Pop3BeginSession()) throw this->fail("pop3BeginSession");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::pop3BeginSessionAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.pop3BeginSessionAsync", std::move(_parts), [_self]() {
+    _self->pop3BeginSession_impl();
+  });
+}
+
+void HybridMailMan::pop3Connect() {
+  this->beginCall();
+  pop3Connect_impl();
+}
+void HybridMailMan::pop3Connect_impl() {
+  if (!this->ck().Pop3Connect()) throw this->fail("pop3Connect");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::pop3ConnectAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.pop3ConnectAsync", std::move(_parts), [_self]() {
+    _self->pop3Connect_impl();
+  });
+}
+
+void HybridMailMan::pop3EndSession() {
+  this->beginCall();
+  pop3EndSession_impl();
+}
+void HybridMailMan::pop3EndSession_impl() {
+  if (!this->ck().Pop3EndSession()) throw this->fail("pop3EndSession");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::pop3EndSessionAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.pop3EndSessionAsync", std::move(_parts), [_self]() {
+    _self->pop3EndSession_impl();
+  });
+}
+
+void HybridMailMan::pop3EndSessionNoQuit() {
+  this->beginCall();
+  pop3EndSessionNoQuit_impl();
+}
+void HybridMailMan::pop3EndSessionNoQuit_impl() {
+  if (!this->ck().Pop3EndSessionNoQuit()) throw this->fail("pop3EndSessionNoQuit");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::pop3EndSessionNoQuitAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.pop3EndSessionNoQuitAsync", std::move(_parts), [_self]() {
+    _self->pop3EndSessionNoQuit_impl();
+  });
+}
+
+void HybridMailMan::pop3Noop() {
+  this->beginCall();
+  pop3Noop_impl();
+}
+void HybridMailMan::pop3Noop_impl() {
+  if (!this->ck().Pop3Noop()) throw this->fail("pop3Noop");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::pop3NoopAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.pop3NoopAsync", std::move(_parts), [_self]() {
+    _self->pop3Noop_impl();
+  });
+}
+
+void HybridMailMan::pop3Reset() {
+  this->beginCall();
+  pop3Reset_impl();
+}
+void HybridMailMan::pop3Reset_impl() {
+  if (!this->ck().Pop3Reset()) throw this->fail("pop3Reset");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::pop3ResetAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.pop3ResetAsync", std::move(_parts), [_self]() {
+    _self->pop3Reset_impl();
+  });
+}
+
+std::string HybridMailMan::pop3SendRawCommand(const std::string& command, const std::string& charset) {
+  this->beginCall();
+  return pop3SendRawCommand_impl(command, charset);
+}
+std::string HybridMailMan::pop3SendRawCommand_impl(const std::string& command, const std::string& charset) {
+  rt::checkNoNul(command, "command");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().Pop3SendRawCommand(command.c_str(), charset.c_str(), _out)) throw this->fail("pop3SendRawCommand");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridMailMan::pop3SendRawCommandAsync(const std::string& command, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("MailMan.pop3SendRawCommandAsync", std::move(_parts), [_self, command, charset]() {
+    return _self->pop3SendRawCommand_impl(command, charset);
+  });
+}
+
+void HybridMailMan::quickSend(const std::string& fromAddr, const std::string& toAddr, const std::string& subject, const std::string& body, const std::string& smtpServer) {
+  this->beginCall();
+  quickSend_impl(fromAddr, toAddr, subject, body, smtpServer);
+}
+void HybridMailMan::quickSend_impl(const std::string& fromAddr, const std::string& toAddr, const std::string& subject, const std::string& body, const std::string& smtpServer) {
+  rt::checkNoNul(fromAddr, "fromAddr");
+  rt::checkNoNul(toAddr, "toAddr");
+  rt::checkNoNul(subject, "subject");
+  rt::checkNoNul(body, "body");
+  rt::checkNoNul(smtpServer, "smtpServer");
+  if (!this->ck().QuickSend(fromAddr.c_str(), toAddr.c_str(), subject.c_str(), body.c_str(), smtpServer.c_str())) throw this->fail("quickSend");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::quickSendAsync(const std::string& fromAddr, const std::string& toAddr, const std::string& subject, const std::string& body, const std::string& smtpServer) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.quickSendAsync", std::move(_parts), [_self, fromAddr, toAddr, subject, body, smtpServer]() {
+    _self->quickSend_impl(fromAddr, toAddr, subject, body, smtpServer);
+  });
+}
+
+std::string HybridMailMan::renderToMime(const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  return renderToMime_impl(email);
+}
+std::string HybridMailMan::renderToMime_impl(const std::shared_ptr<HybridEmailSpec>& email) {
+  CkString _out;
+  if (!this->ck().RenderToMime(rt::implOf<HybridEmail>(email, "email").ck(), _out)) throw this->fail("renderToMime");
+  return rt::stdString(_out);
+}
+
+void HybridMailMan::sendBundle(const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  this->beginCall();
+  sendBundle_impl(bundle);
+}
+void HybridMailMan::sendBundle_impl(const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  if (!this->ck().SendBundle(rt::implOf<HybridEmailBundle>(bundle, "bundle").ck())) throw this->fail("sendBundle");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::sendBundleAsync(const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bundle);
+  return rt::runAsync<void>("MailMan.sendBundleAsync", std::move(_parts), [_self, bundle]() {
+    _self->sendBundle_impl(bundle);
+  });
+}
+
+void HybridMailMan::sendEmail(const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  sendEmail_impl(email);
+}
+void HybridMailMan::sendEmail_impl(const std::shared_ptr<HybridEmailSpec>& email) {
+  if (!this->ck().SendEmail(rt::implOf<HybridEmail>(email, "email").ck())) throw this->fail("sendEmail");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::sendEmailAsync(const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(email);
+  return rt::runAsync<void>("MailMan.sendEmailAsync", std::move(_parts), [_self, email]() {
+    _self->sendEmail_impl(email);
+  });
+}
+
+void HybridMailMan::sendMime(const std::string& fromAddr, const std::string& recipients, const std::string& mimeSource) {
+  this->beginCall();
+  sendMime_impl(fromAddr, recipients, mimeSource);
+}
+void HybridMailMan::sendMime_impl(const std::string& fromAddr, const std::string& recipients, const std::string& mimeSource) {
+  rt::checkNoNul(fromAddr, "fromAddr");
+  rt::checkNoNul(recipients, "recipients");
+  rt::checkNoNul(mimeSource, "mimeSource");
+  if (!this->ck().SendMime(fromAddr.c_str(), recipients.c_str(), mimeSource.c_str())) throw this->fail("sendMime");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::sendMimeAsync(const std::string& fromAddr, const std::string& recipients, const std::string& mimeSource) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.sendMimeAsync", std::move(_parts), [_self, fromAddr, recipients, mimeSource]() {
+    _self->sendMime_impl(fromAddr, recipients, mimeSource);
+  });
+}
+
+void HybridMailMan::setDecryptCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setDecryptCert_impl(cert);
+}
+void HybridMailMan::setDecryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetDecryptCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setDecryptCert");
+}
+
+void HybridMailMan::setDecryptCert2(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) {
+  this->beginCall();
+  setDecryptCert2_impl(cert, privateKey);
+}
+void HybridMailMan::setDecryptCert2_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& privateKey) {
+  if (!this->ck().SetDecryptCert2(rt::implOf<HybridCert>(cert, "cert").ck(), rt::implOf<HybridPrivateKey>(privateKey, "privateKey").ck())) throw this->fail("setDecryptCert2");
+}
+
+void HybridMailMan::setSslClientCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setSslClientCert_impl(cert);
+}
+void HybridMailMan::setSslClientCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetSslClientCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setSslClientCert");
+}
+
+void HybridMailMan::setSslClientCertPem(const std::string& pemDataOrFilename, const std::string& pemPassword) {
+  this->beginCall();
+  setSslClientCertPem_impl(pemDataOrFilename, pemPassword);
+}
+void HybridMailMan::setSslClientCertPem_impl(const std::string& pemDataOrFilename, const std::string& pemPassword) {
+  rt::checkNoNul(pemDataOrFilename, "pemDataOrFilename");
+  rt::checkNoNul(pemPassword, "pemPassword");
+  if (!this->ck().SetSslClientCertPem(pemDataOrFilename.c_str(), pemPassword.c_str())) throw this->fail("setSslClientCertPem");
+}
+
+void HybridMailMan::setSslClientCertPfx(const std::string& pfxPath, const std::string& pfxPassword) {
+  this->beginCall();
+  setSslClientCertPfx_impl(pfxPath, pfxPassword);
+}
+void HybridMailMan::setSslClientCertPfx_impl(const std::string& pfxPath, const std::string& pfxPassword) {
+  rt::checkNoNul(pfxPath, "pfxPath");
+  rt::checkNoNul(pfxPassword, "pfxPassword");
+  if (!this->ck().SetSslClientCertPfx(pfxPath.c_str(), pfxPassword.c_str())) throw this->fail("setSslClientCertPfx");
+}
+
+void HybridMailMan::smtpAuthenticate() {
+  this->beginCall();
+  smtpAuthenticate_impl();
+}
+void HybridMailMan::smtpAuthenticate_impl() {
+  if (!this->ck().SmtpAuthenticate()) throw this->fail("smtpAuthenticate");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::smtpAuthenticateAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.smtpAuthenticateAsync", std::move(_parts), [_self]() {
+    _self->smtpAuthenticate_impl();
+  });
+}
+
+void HybridMailMan::smtpConnect() {
+  this->beginCall();
+  smtpConnect_impl();
+}
+void HybridMailMan::smtpConnect_impl() {
+  if (!this->ck().SmtpConnect()) throw this->fail("smtpConnect");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::smtpConnectAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.smtpConnectAsync", std::move(_parts), [_self]() {
+    _self->smtpConnect_impl();
+  });
+}
+
+void HybridMailMan::smtpNoop() {
+  this->beginCall();
+  smtpNoop_impl();
+}
+void HybridMailMan::smtpNoop_impl() {
+  if (!this->ck().SmtpNoop()) throw this->fail("smtpNoop");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::smtpNoopAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.smtpNoopAsync", std::move(_parts), [_self]() {
+    _self->smtpNoop_impl();
+  });
+}
+
+void HybridMailMan::smtpReset() {
+  this->beginCall();
+  smtpReset_impl();
+}
+void HybridMailMan::smtpReset_impl() {
+  if (!this->ck().SmtpReset()) throw this->fail("smtpReset");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::smtpResetAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.smtpResetAsync", std::move(_parts), [_self]() {
+    _self->smtpReset_impl();
+  });
+}
+
+std::string HybridMailMan::smtpSendRawCommand(const std::string& command, const std::string& charset, bool bEncodeBase64) {
+  this->beginCall();
+  return smtpSendRawCommand_impl(command, charset, bEncodeBase64);
+}
+std::string HybridMailMan::smtpSendRawCommand_impl(const std::string& command, const std::string& charset, bool bEncodeBase64) {
+  rt::checkNoNul(command, "command");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().SmtpSendRawCommand(command.c_str(), charset.c_str(), bEncodeBase64, _out)) throw this->fail("smtpSendRawCommand");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridMailMan::smtpSendRawCommandAsync(const std::string& command, const std::string& charset, bool bEncodeBase64) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("MailMan.smtpSendRawCommandAsync", std::move(_parts), [_self, command, charset, bEncodeBase64]() {
+    return _self->smtpSendRawCommand_impl(command, charset, bEncodeBase64);
+  });
+}
+
+void HybridMailMan::sshAuthenticatePk(const std::string& sshLogin, const std::shared_ptr<HybridSshKeySpec>& privKey) {
+  this->beginCall();
+  sshAuthenticatePk_impl(sshLogin, privKey);
+}
+void HybridMailMan::sshAuthenticatePk_impl(const std::string& sshLogin, const std::shared_ptr<HybridSshKeySpec>& privKey) {
+  rt::checkNoNul(sshLogin, "sshLogin");
+  if (!this->ck().SshAuthenticatePk(sshLogin.c_str(), rt::implOf<HybridSshKey>(privKey, "privKey").ck())) throw this->fail("sshAuthenticatePk");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::sshAuthenticatePkAsync(const std::string& sshLogin, const std::shared_ptr<HybridSshKeySpec>& privKey) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(privKey);
+  return rt::runAsync<void>("MailMan.sshAuthenticatePkAsync", std::move(_parts), [_self, sshLogin, privKey]() {
+    _self->sshAuthenticatePk_impl(sshLogin, privKey);
+  });
+}
+
+void HybridMailMan::sshAuthenticatePw(const std::string& sshLogin, const std::string& sshPassword) {
+  this->beginCall();
+  sshAuthenticatePw_impl(sshLogin, sshPassword);
+}
+void HybridMailMan::sshAuthenticatePw_impl(const std::string& sshLogin, const std::string& sshPassword) {
+  rt::checkNoNul(sshLogin, "sshLogin");
+  rt::checkNoNul(sshPassword, "sshPassword");
+  if (!this->ck().SshAuthenticatePw(sshLogin.c_str(), sshPassword.c_str())) throw this->fail("sshAuthenticatePw");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::sshAuthenticatePwAsync(const std::string& sshLogin, const std::string& sshPassword) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.sshAuthenticatePwAsync", std::move(_parts), [_self, sshLogin, sshPassword]() {
+    _self->sshAuthenticatePw_impl(sshLogin, sshPassword);
+  });
+}
+
+void HybridMailMan::sshCloseTunnel() {
+  this->beginCall();
+  sshCloseTunnel_impl();
+}
+void HybridMailMan::sshCloseTunnel_impl() {
+  if (!this->ck().SshCloseTunnel()) throw this->fail("sshCloseTunnel");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::sshCloseTunnelAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.sshCloseTunnelAsync", std::move(_parts), [_self]() {
+    _self->sshCloseTunnel_impl();
+  });
+}
+
+void HybridMailMan::sshOpenTunnel(const std::string& sshHostname, double sshPort) {
+  this->beginCall();
+  sshOpenTunnel_impl(sshHostname, sshPort);
+}
+void HybridMailMan::sshOpenTunnel_impl(const std::string& sshHostname, double sshPort) {
+  rt::checkNoNul(sshHostname, "sshHostname");
+  if (!this->ck().SshOpenTunnel(sshHostname.c_str(), rt::toInt(sshPort, "sshPort"))) throw this->fail("sshOpenTunnel");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::sshOpenTunnelAsync(const std::string& sshHostname, double sshPort) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("MailMan.sshOpenTunnelAsync", std::move(_parts), [_self, sshHostname, sshPort]() {
+    _self->sshOpenTunnel_impl(sshHostname, sshPort);
+  });
+}
+
+void HybridMailMan::useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  this->beginCall();
+  useCertVault_impl(vault);
+}
+void HybridMailMan::useCertVault_impl(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  if (!this->ck().UseCertVault(rt::implOf<HybridXmlCertVault>(vault, "vault").ck())) throw this->fail("useCertVault");
+}
+
+void HybridMailMan::useSsh(const std::shared_ptr<HybridSshSpec>& ssh) {
+  this->beginCall();
+  useSsh_impl(ssh);
+}
+void HybridMailMan::useSsh_impl(const std::shared_ptr<HybridSshSpec>& ssh) {
+  if (!this->ck().UseSsh(rt::implOf<HybridSsh>(ssh, "ssh").ck())) throw this->fail("useSsh");
+}
+
+void HybridMailMan::useSshTunnel(const std::shared_ptr<HybridSocketSpec>& tunnel) {
+  this->beginCall();
+  useSshTunnel_impl(tunnel);
+}
+void HybridMailMan::useSshTunnel_impl(const std::shared_ptr<HybridSocketSpec>& tunnel) {
+  if (!this->ck().UseSshTunnel(rt::implOf<HybridSocket>(tunnel, "tunnel").ck())) throw this->fail("useSshTunnel");
+}
+
+bool HybridMailMan::verifyPopConnection() {
+  this->beginCall();
+  return verifyPopConnection_impl();
+}
+bool HybridMailMan::verifyPopConnection_impl() {
+  return this->ck().VerifyPopConnection();
+}
+std::shared_ptr<Promise<bool>> HybridMailMan::verifyPopConnectionAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<bool>("MailMan.verifyPopConnectionAsync", std::move(_parts), [_self]() {
+    return _self->verifyPopConnection_impl();
+  });
+}
+
+bool HybridMailMan::verifyPopLogin() {
+  this->beginCall();
+  return verifyPopLogin_impl();
+}
+bool HybridMailMan::verifyPopLogin_impl() {
+  return this->ck().VerifyPopLogin();
+}
+std::shared_ptr<Promise<bool>> HybridMailMan::verifyPopLoginAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<bool>("MailMan.verifyPopLoginAsync", std::move(_parts), [_self]() {
+    return _self->verifyPopLogin_impl();
+  });
+}
+
+void HybridMailMan::verifyRecips(const std::shared_ptr<HybridEmailSpec>& email, const std::shared_ptr<HybridStringArraySpec>& badAddrs) {
+  this->beginCall();
+  verifyRecips_impl(email, badAddrs);
+}
+void HybridMailMan::verifyRecips_impl(const std::shared_ptr<HybridEmailSpec>& email, const std::shared_ptr<HybridStringArraySpec>& badAddrs) {
+  if (!this->ck().VerifyRecips(rt::implOf<HybridEmail>(email, "email").ck(), rt::implOf<HybridStringArray>(badAddrs, "badAddrs").ck())) throw this->fail("verifyRecips");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::verifyRecipsAsync(const std::shared_ptr<HybridEmailSpec>& email, const std::shared_ptr<HybridStringArraySpec>& badAddrs) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(email);
+  _parts.push_back(badAddrs);
+  return rt::runAsync<void>("MailMan.verifyRecipsAsync", std::move(_parts), [_self, email, badAddrs]() {
+    _self->verifyRecips_impl(email, badAddrs);
+  });
+}
+
+bool HybridMailMan::verifySmtpConnection() {
+  this->beginCall();
+  return verifySmtpConnection_impl();
+}
+bool HybridMailMan::verifySmtpConnection_impl() {
+  return this->ck().VerifySmtpConnection();
+}
+std::shared_ptr<Promise<bool>> HybridMailMan::verifySmtpConnectionAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<bool>("MailMan.verifySmtpConnectionAsync", std::move(_parts), [_self]() {
+    return _self->verifySmtpConnection_impl();
+  });
+}
+
+bool HybridMailMan::verifySmtpLogin() {
+  this->beginCall();
+  return verifySmtpLogin_impl();
+}
+bool HybridMailMan::verifySmtpLogin_impl() {
+  return this->ck().VerifySmtpLogin();
+}
+std::shared_ptr<Promise<bool>> HybridMailMan::verifySmtpLoginAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<bool>("MailMan.verifySmtpLoginAsync", std::move(_parts), [_self]() {
+    return _self->verifySmtpLogin_impl();
+  });
+}
+
+void HybridMailMan::renderToMimeSb(const std::shared_ptr<HybridEmailSpec>& email, const std::shared_ptr<HybridStringBuilderSpec>& renderedMime) {
+  this->beginCall();
+  renderToMimeSb_impl(email, renderedMime);
+}
+void HybridMailMan::renderToMimeSb_impl(const std::shared_ptr<HybridEmailSpec>& email, const std::shared_ptr<HybridStringBuilderSpec>& renderedMime) {
+  if (!this->ck().RenderToMimeSb(rt::implOf<HybridEmail>(email, "email").ck(), rt::implOf<HybridStringBuilder>(renderedMime, "renderedMime").ck())) throw this->fail("renderToMimeSb");
+}
+
+void HybridMailMan::renderToMimeBd(const std::shared_ptr<HybridEmailSpec>& email, const std::shared_ptr<HybridBinDataSpec>& renderedMime) {
+  this->beginCall();
+  renderToMimeBd_impl(email, renderedMime);
+}
+void HybridMailMan::renderToMimeBd_impl(const std::shared_ptr<HybridEmailSpec>& email, const std::shared_ptr<HybridBinDataSpec>& renderedMime) {
+  if (!this->ck().RenderToMimeBd(rt::implOf<HybridEmail>(email, "email").ck(), rt::implOf<HybridBinData>(renderedMime, "renderedMime").ck())) throw this->fail("renderToMimeBd");
+}
+
+void HybridMailMan::setPassword(const std::string& protocolName, const std::shared_ptr<HybridSecureStringSpec>& password) {
+  this->beginCall();
+  setPassword_impl(protocolName, password);
+}
+void HybridMailMan::setPassword_impl(const std::string& protocolName, const std::shared_ptr<HybridSecureStringSpec>& password) {
+  rt::checkNoNul(protocolName, "protocolName");
+  if (!this->ck().SetPassword(protocolName.c_str(), rt::implOf<HybridSecureString>(password, "password").ck())) throw this->fail("setPassword");
+}
+
+void HybridMailMan::sendMimeBd(const std::string& fromAddr, const std::string& recipients, const std::shared_ptr<HybridBinDataSpec>& mimeData) {
+  this->beginCall();
+  sendMimeBd_impl(fromAddr, recipients, mimeData);
+}
+void HybridMailMan::sendMimeBd_impl(const std::string& fromAddr, const std::string& recipients, const std::shared_ptr<HybridBinDataSpec>& mimeData) {
+  rt::checkNoNul(fromAddr, "fromAddr");
+  rt::checkNoNul(recipients, "recipients");
+  if (!this->ck().SendMimeBd(fromAddr.c_str(), recipients.c_str(), rt::implOf<HybridBinData>(mimeData, "mimeData").ck())) throw this->fail("sendMimeBd");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::sendMimeBdAsync(const std::string& fromAddr, const std::string& recipients, const std::shared_ptr<HybridBinDataSpec>& mimeData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(mimeData);
+  return rt::runAsync<void>("MailMan.sendMimeBdAsync", std::move(_parts), [_self, fromAddr, recipients, mimeData]() {
+    _self->sendMimeBd_impl(fromAddr, recipients, mimeData);
+  });
+}
+
+void HybridMailMan::fetchMimeBd(const std::string& uidl, const std::shared_ptr<HybridBinDataSpec>& mimeData) {
+  this->beginCall();
+  fetchMimeBd_impl(uidl, mimeData);
+}
+void HybridMailMan::fetchMimeBd_impl(const std::string& uidl, const std::shared_ptr<HybridBinDataSpec>& mimeData) {
+  rt::checkNoNul(uidl, "uidl");
+  if (!this->ck().FetchMimeBd(uidl.c_str(), rt::implOf<HybridBinData>(mimeData, "mimeData").ck())) throw this->fail("fetchMimeBd");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::fetchMimeBdAsync(const std::string& uidl, const std::shared_ptr<HybridBinDataSpec>& mimeData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(mimeData);
+  return rt::runAsync<void>("MailMan.fetchMimeBdAsync", std::move(_parts), [_self, uidl, mimeData]() {
+    _self->fetchMimeBd_impl(uidl, mimeData);
+  });
+}
+
+void HybridMailMan::getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getLastJsonData_impl(json);
+}
+void HybridMailMan::getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->ck().GetLastJsonData(rt::implOf<HybridJsonObject>(json, "json").ck());
+}
+
+void HybridMailMan::getServerCert(bool useSmtp, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  getServerCert_impl(useSmtp, cert);
+}
+void HybridMailMan::getServerCert_impl(bool useSmtp, const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().GetServerCert(useSmtp, rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("getServerCert");
+}
+
+void HybridMailMan::fetchAll(bool keepOnServer, bool headersOnly, double numBodyLines, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  this->beginCall();
+  fetchAll_impl(keepOnServer, headersOnly, numBodyLines, bundle);
+}
+void HybridMailMan::fetchAll_impl(bool keepOnServer, bool headersOnly, double numBodyLines, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  if (!this->ck().FetchAll(keepOnServer, headersOnly, rt::toInt(numBodyLines, "numBodyLines"), rt::implOf<HybridEmailBundle>(bundle, "bundle").ck())) throw this->fail("fetchAll");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::fetchAllAsync(bool keepOnServer, bool headersOnly, double numBodyLines, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bundle);
+  return rt::runAsync<void>("MailMan.fetchAllAsync", std::move(_parts), [_self, keepOnServer, headersOnly, numBodyLines, bundle]() {
+    _self->fetchAll_impl(keepOnServer, headersOnly, numBodyLines, bundle);
+  });
+}
+
+void HybridMailMan::fetchRange(bool keepOnServer, bool headersOnly, double numBodyLines, double startIndex, double endIndex, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  this->beginCall();
+  fetchRange_impl(keepOnServer, headersOnly, numBodyLines, startIndex, endIndex, bundle);
+}
+void HybridMailMan::fetchRange_impl(bool keepOnServer, bool headersOnly, double numBodyLines, double startIndex, double endIndex, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  if (!this->ck().FetchRange(keepOnServer, headersOnly, rt::toInt(numBodyLines, "numBodyLines"), rt::toInt(startIndex, "startIndex"), rt::toInt(endIndex, "endIndex"), rt::implOf<HybridEmailBundle>(bundle, "bundle").ck())) throw this->fail("fetchRange");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::fetchRangeAsync(bool keepOnServer, bool headersOnly, double numBodyLines, double startIndex, double endIndex, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bundle);
+  return rt::runAsync<void>("MailMan.fetchRangeAsync", std::move(_parts), [_self, keepOnServer, headersOnly, numBodyLines, startIndex, endIndex, bundle]() {
+    _self->fetchRange_impl(keepOnServer, headersOnly, numBodyLines, startIndex, endIndex, bundle);
+  });
+}
+
+void HybridMailMan::fetchOne(bool headerOnly, double numBodyLines, double msgNum, const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  fetchOne_impl(headerOnly, numBodyLines, msgNum, email);
+}
+void HybridMailMan::fetchOne_impl(bool headerOnly, double numBodyLines, double msgNum, const std::shared_ptr<HybridEmailSpec>& email) {
+  if (!this->ck().FetchOne(headerOnly, rt::toInt(numBodyLines, "numBodyLines"), rt::toInt(msgNum, "msgNum"), rt::implOf<HybridEmail>(email, "email").ck())) throw this->fail("fetchOne");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::fetchOneAsync(bool headerOnly, double numBodyLines, double msgNum, const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(email);
+  return rt::runAsync<void>("MailMan.fetchOneAsync", std::move(_parts), [_self, headerOnly, numBodyLines, msgNum, email]() {
+    _self->fetchOne_impl(headerOnly, numBodyLines, msgNum, email);
+  });
+}
+
+void HybridMailMan::fetchByUidl(const std::string& uidl, bool headerOnly, double numBodyLines, const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  fetchByUidl_impl(uidl, headerOnly, numBodyLines, email);
+}
+void HybridMailMan::fetchByUidl_impl(const std::string& uidl, bool headerOnly, double numBodyLines, const std::shared_ptr<HybridEmailSpec>& email) {
+  rt::checkNoNul(uidl, "uidl");
+  if (!this->ck().FetchByUidl(uidl.c_str(), headerOnly, rt::toInt(numBodyLines, "numBodyLines"), rt::implOf<HybridEmail>(email, "email").ck())) throw this->fail("fetchByUidl");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::fetchByUidlAsync(const std::string& uidl, bool headerOnly, double numBodyLines, const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(email);
+  return rt::runAsync<void>("MailMan.fetchByUidlAsync", std::move(_parts), [_self, uidl, headerOnly, numBodyLines, email]() {
+    _self->fetchByUidl_impl(uidl, headerOnly, numBodyLines, email);
+  });
+}
+
+void HybridMailMan::fetchUidlSet(const std::shared_ptr<HybridStringTableSpec>& uidls, bool headersOnly, double numBodyLines, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  this->beginCall();
+  fetchUidlSet_impl(uidls, headersOnly, numBodyLines, bundle);
+}
+void HybridMailMan::fetchUidlSet_impl(const std::shared_ptr<HybridStringTableSpec>& uidls, bool headersOnly, double numBodyLines, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  if (!this->ck().FetchUidlSet(rt::implOf<HybridStringTable>(uidls, "uidls").ck(), headersOnly, rt::toInt(numBodyLines, "numBodyLines"), rt::implOf<HybridEmailBundle>(bundle, "bundle").ck())) throw this->fail("fetchUidlSet");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::fetchUidlSetAsync(const std::shared_ptr<HybridStringTableSpec>& uidls, bool headersOnly, double numBodyLines, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(uidls);
+  _parts.push_back(bundle);
+  return rt::runAsync<void>("MailMan.fetchUidlSetAsync", std::move(_parts), [_self, uidls, headersOnly, numBodyLines, bundle]() {
+    _self->fetchUidlSet_impl(uidls, headersOnly, numBodyLines, bundle);
+  });
+}
+
+void HybridMailMan::fetchFull(const std::shared_ptr<HybridEmailSpec>& partialEmail, const std::shared_ptr<HybridEmailSpec>& fullEmail) {
+  this->beginCall();
+  fetchFull_impl(partialEmail, fullEmail);
+}
+void HybridMailMan::fetchFull_impl(const std::shared_ptr<HybridEmailSpec>& partialEmail, const std::shared_ptr<HybridEmailSpec>& fullEmail) {
+  if (!this->ck().FetchFull(rt::implOf<HybridEmail>(partialEmail, "partialEmail").ck(), rt::implOf<HybridEmail>(fullEmail, "fullEmail").ck())) throw this->fail("fetchFull");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::fetchFullAsync(const std::shared_ptr<HybridEmailSpec>& partialEmail, const std::shared_ptr<HybridEmailSpec>& fullEmail) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(partialEmail);
+  _parts.push_back(fullEmail);
+  return rt::runAsync<void>("MailMan.fetchFullAsync", std::move(_parts), [_self, partialEmail, fullEmail]() {
+    _self->fetchFull_impl(partialEmail, fullEmail);
+  });
+}
+
+void HybridMailMan::loadMbxFile(const std::string& mbxPath, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  this->beginCall();
+  loadMbxFile_impl(mbxPath, bundle);
+}
+void HybridMailMan::loadMbxFile_impl(const std::string& mbxPath, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  rt::checkNoNul(mbxPath, "mbxPath");
+  if (!this->ck().LoadMbxFile(mbxPath.c_str(), rt::implOf<HybridEmailBundle>(bundle, "bundle").ck())) throw this->fail("loadMbxFile");
+}
+
+void HybridMailMan::fetchUidls(const std::shared_ptr<HybridStringTableSpec>& uidls) {
+  this->beginCall();
+  fetchUidls_impl(uidls);
+}
+void HybridMailMan::fetchUidls_impl(const std::shared_ptr<HybridStringTableSpec>& uidls) {
+  if (!this->ck().FetchUidls(rt::implOf<HybridStringTable>(uidls, "uidls").ck())) throw this->fail("fetchUidls");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::fetchUidlsAsync(const std::shared_ptr<HybridStringTableSpec>& uidls) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(uidls);
+  return rt::runAsync<void>("MailMan.fetchUidlsAsync", std::move(_parts), [_self, uidls]() {
+    _self->fetchUidls_impl(uidls);
+  });
+}
+
+void HybridMailMan::addPfxSourceBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) {
+  this->beginCall();
+  addPfxSourceBd_impl(bd, password);
+}
+void HybridMailMan::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 HybridMailMan::fetchMimeByMsgnumBd(double msgnum, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  fetchMimeByMsgnumBd_impl(msgnum, bd);
+}
+void HybridMailMan::fetchMimeByMsgnumBd_impl(double msgnum, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().FetchMimeByMsgnumBd(rt::toInt(msgnum, "msgnum"), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("fetchMimeByMsgnumBd");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::fetchMimeByMsgnumBdAsync(double msgnum, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("MailMan.fetchMimeByMsgnumBdAsync", std::move(_parts), [_self, msgnum, bd]() {
+    _self->fetchMimeByMsgnumBd_impl(msgnum, bd);
+  });
+}
+
+void HybridMailMan::deleteUidlSet(const std::shared_ptr<HybridStringTableSpec>& stUidls) {
+  this->beginCall();
+  deleteUidlSet_impl(stUidls);
+}
+void HybridMailMan::deleteUidlSet_impl(const std::shared_ptr<HybridStringTableSpec>& stUidls) {
+  if (!this->ck().DeleteUidlSet(rt::implOf<HybridStringTable>(stUidls, "stUidls").ck())) throw this->fail("deleteUidlSet");
+}
+std::shared_ptr<Promise<void>> HybridMailMan::deleteUidlSetAsync(const std::shared_ptr<HybridStringTableSpec>& stUidls) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMailMan>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(stUidls);
+  return rt::runAsync<void>("MailMan.deleteUidlSetAsync", std::move(_parts), [_self, stUidls]() {
+    _self->deleteUidlSet_impl(stUidls);
+  });
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridMailMan::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridMailMan::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridMailMan::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridMailMan::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridMailMan::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat