@chilkat/react-native 11.6.1

package/cpp/HybridImap.cpp

@@ -0,0 +1,1818 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridImap.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCert.hpp"
+#include "HybridEmail.hpp"
+#include "HybridEmailBundle.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridMailboxes.hpp"
+#include "HybridMessageSet.hpp"
+#include "HybridPrivateKey.hpp"
+#include "HybridSecureString.hpp"
+#include "HybridSocket.hpp"
+#include "HybridSsh.hpp"
+#include "HybridSshKey.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridXmlCertVault.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridImap::HybridImap()
+    : HybridObject(HybridImapSpec::TAG), ChilkatObject<CkImap>("Imap", CkImap::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridImap::HybridImap(CkImap* owned)
+    : HybridObject(HybridImapSpec::TAG), ChilkatObject<CkImap>("Imap", owned) {
+  init();
+}
+
+void HybridImap::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridImap::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridImap::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridImap::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridImap::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridImap::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridImap::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridImap::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridImap::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridImap::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridImap::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridImap::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridImap::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+bool HybridImap::getAppendSeen() {
+  this->beginCall();
+  return this->ck().get_AppendSeen();
+}
+void HybridImap::setAppendSeen(bool value) {
+  this->beginCall();
+  this->ck().put_AppendSeen(value);
+}
+double HybridImap::getAppendUid() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_AppendUid());
+}
+std::string HybridImap::getAuthMethod() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AuthMethod(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setAuthMethod(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "authMethod");
+  this->ck().put_AuthMethod(value.c_str());
+}
+std::string HybridImap::getAuthzId() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AuthzId(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setAuthzId(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "authzId");
+  this->ck().put_AuthzId(value.c_str());
+}
+bool HybridImap::getAutoDownloadAttachments() {
+  this->beginCall();
+  return this->ck().get_AutoDownloadAttachments();
+}
+void HybridImap::setAutoDownloadAttachments(bool value) {
+  this->beginCall();
+  this->ck().put_AutoDownloadAttachments(value);
+}
+bool HybridImap::getAutoFix() {
+  this->beginCall();
+  return this->ck().get_AutoFix();
+}
+void HybridImap::setAutoFix(bool value) {
+  this->beginCall();
+  this->ck().put_AutoFix(value);
+}
+std::string HybridImap::getClientIpAddress() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ClientIpAddress(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setClientIpAddress(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "clientIpAddress");
+  this->ck().put_ClientIpAddress(value.c_str());
+}
+double HybridImap::getConnectTimeout() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectTimeout());
+}
+void HybridImap::setConnectTimeout(double value) {
+  this->beginCall();
+  this->ck().put_ConnectTimeout(rt::toInt(value, "connectTimeout"));
+}
+std::string HybridImap::getConnectedToHost() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ConnectedToHost(_s);
+  return rt::stdString(_s);
+}
+std::string HybridImap::getDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Domain(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "domain");
+  this->ck().put_Domain(value.c_str());
+}
+double HybridImap::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridImap::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+std::string HybridImap::getHttpProxyAuthMethod() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyAuthMethod(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setHttpProxyAuthMethod(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyAuthMethod");
+  this->ck().put_HttpProxyAuthMethod(value.c_str());
+}
+std::string HybridImap::getHttpProxyDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyDomain(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setHttpProxyDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyDomain");
+  this->ck().put_HttpProxyDomain(value.c_str());
+}
+std::string HybridImap::getHttpProxyHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setHttpProxyHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyHostname");
+  this->ck().put_HttpProxyHostname(value.c_str());
+}
+std::string HybridImap::getHttpProxyPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setHttpProxyPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyPassword");
+  this->ck().put_HttpProxyPassword(value.c_str());
+}
+double HybridImap::getHttpProxyPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HttpProxyPort());
+}
+void HybridImap::setHttpProxyPort(double value) {
+  this->beginCall();
+  this->ck().put_HttpProxyPort(rt::toInt(value, "httpProxyPort"));
+}
+std::string HybridImap::getHttpProxyUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setHttpProxyUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyUsername");
+  this->ck().put_HttpProxyUsername(value.c_str());
+}
+bool HybridImap::getKeepSessionLog() {
+  this->beginCall();
+  return this->ck().get_KeepSessionLog();
+}
+void HybridImap::setKeepSessionLog(bool value) {
+  this->beginCall();
+  this->ck().put_KeepSessionLog(value);
+}
+std::string HybridImap::getLastAppendedMime() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastAppendedMime(_s);
+  return rt::stdString(_s);
+}
+std::string HybridImap::getLastCommand() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastCommand(_s);
+  return rt::stdString(_s);
+}
+std::string HybridImap::getLastIntermediateResponse() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastIntermediateResponse(_s);
+  return rt::stdString(_s);
+}
+std::string HybridImap::getLastResponse() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastResponse(_s);
+  return rt::stdString(_s);
+}
+std::string HybridImap::getLastResponseCode() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastResponseCode(_s);
+  return rt::stdString(_s);
+}
+std::string HybridImap::getLoggedInUser() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LoggedInUser(_s);
+  return rt::stdString(_s);
+}
+double HybridImap::getNumMessages() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumMessages());
+}
+bool HybridImap::getPeekMode() {
+  this->beginCall();
+  return this->ck().get_PeekMode();
+}
+void HybridImap::setPeekMode(bool value) {
+  this->beginCall();
+  this->ck().put_PeekMode(value);
+}
+double HybridImap::getPercentDoneScale() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_PercentDoneScale());
+}
+void HybridImap::setPercentDoneScale(double value) {
+  this->beginCall();
+  this->ck().put_PercentDoneScale(rt::toInt(value, "percentDoneScale"));
+}
+double HybridImap::getPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Port());
+}
+void HybridImap::setPort(double value) {
+  this->beginCall();
+  this->ck().put_Port(rt::toInt(value, "port"));
+}
+bool HybridImap::getPreferIpv6() {
+  this->beginCall();
+  return this->ck().get_PreferIpv6();
+}
+void HybridImap::setPreferIpv6(bool value) {
+  this->beginCall();
+  this->ck().put_PreferIpv6(value);
+}
+double HybridImap::getReadTimeout() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ReadTimeout());
+}
+void HybridImap::setReadTimeout(double value) {
+  this->beginCall();
+  this->ck().put_ReadTimeout(rt::toInt(value, "readTimeout"));
+}
+bool HybridImap::getRequireSslCertVerify() {
+  this->beginCall();
+  return this->ck().get_RequireSslCertVerify();
+}
+void HybridImap::setRequireSslCertVerify(bool value) {
+  this->beginCall();
+  this->ck().put_RequireSslCertVerify(value);
+}
+std::string HybridImap::getSearchCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SearchCharset(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setSearchCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "searchCharset");
+  this->ck().put_SearchCharset(value.c_str());
+}
+std::string HybridImap::getSelectedMailbox() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SelectedMailbox(_s);
+  return rt::stdString(_s);
+}
+double HybridImap::getSendBufferSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SendBufferSize());
+}
+void HybridImap::setSendBufferSize(double value) {
+  this->beginCall();
+  this->ck().put_SendBufferSize(rt::toInt(value, "sendBufferSize"));
+}
+std::string HybridImap::getSeparatorChar() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SeparatorChar(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setSeparatorChar(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "separatorChar");
+  this->ck().put_SeparatorChar(value.c_str());
+}
+std::string HybridImap::getSessionLog() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SessionLog(_s);
+  return rt::stdString(_s);
+}
+double HybridImap::getSoRcvBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoRcvBuf());
+}
+void HybridImap::setSoRcvBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoRcvBuf(rt::toInt(value, "soRcvBuf"));
+}
+double HybridImap::getSoSndBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoSndBuf());
+}
+void HybridImap::setSoSndBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoSndBuf(rt::toInt(value, "soSndBuf"));
+}
+std::string HybridImap::getSocksHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setSocksHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksHostname");
+  this->ck().put_SocksHostname(value.c_str());
+}
+std::string HybridImap::getSocksPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setSocksPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksPassword");
+  this->ck().put_SocksPassword(value.c_str());
+}
+double HybridImap::getSocksPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksPort());
+}
+void HybridImap::setSocksPort(double value) {
+  this->beginCall();
+  this->ck().put_SocksPort(rt::toInt(value, "socksPort"));
+}
+std::string HybridImap::getSocksUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setSocksUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksUsername");
+  this->ck().put_SocksUsername(value.c_str());
+}
+double HybridImap::getSocksVersion() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksVersion());
+}
+void HybridImap::setSocksVersion(double value) {
+  this->beginCall();
+  this->ck().put_SocksVersion(rt::toInt(value, "socksVersion"));
+}
+bool HybridImap::getSsl() {
+  this->beginCall();
+  return this->ck().get_Ssl();
+}
+void HybridImap::setSsl(bool value) {
+  this->beginCall();
+  this->ck().put_Ssl(value);
+}
+std::string HybridImap::getSslAllowedCiphers() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SslAllowedCiphers(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setSslAllowedCiphers(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sslAllowedCiphers");
+  this->ck().put_SslAllowedCiphers(value.c_str());
+}
+std::string HybridImap::getSslProtocol() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SslProtocol(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setSslProtocol(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sslProtocol");
+  this->ck().put_SslProtocol(value.c_str());
+}
+bool HybridImap::getSslServerCertVerified() {
+  this->beginCall();
+  return this->ck().get_SslServerCertVerified();
+}
+bool HybridImap::getStartTls() {
+  this->beginCall();
+  return this->ck().get_StartTls();
+}
+void HybridImap::setStartTls(bool value) {
+  this->beginCall();
+  this->ck().put_StartTls(value);
+}
+std::string HybridImap::getTlsCipherSuite() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsCipherSuite(_s);
+  return rt::stdString(_s);
+}
+std::string HybridImap::getTlsPinSet() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsPinSet(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setTlsPinSet(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "tlsPinSet");
+  this->ck().put_TlsPinSet(value.c_str());
+}
+std::string HybridImap::getTlsVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsVersion(_s);
+  return rt::stdString(_s);
+}
+double HybridImap::getUidNext() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_UidNext());
+}
+double HybridImap::getUidValidity() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_UidValidity());
+}
+std::string HybridImap::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+std::string HybridImap::getHighestModSeq() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HighestModSeq(_s);
+  return rt::stdString(_s);
+}
+std::string HybridImap::getSortCriteria() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SortCriteria(_s);
+  return rt::stdString(_s);
+}
+void HybridImap::setSortCriteria(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sortCriteria");
+  this->ck().put_SortCriteria(value.c_str());
+}
+bool HybridImap::getEnableSecrets() {
+  this->beginCall();
+  return this->ck().get_EnableSecrets();
+}
+void HybridImap::setEnableSecrets(bool value) {
+  this->beginCall();
+  this->ck().put_EnableSecrets(value);
+}
+
+// ---- Methods ----
+
+void HybridImap::addPfxSourceFile(const std::string& pfxFilePath, const std::string& pfxPassword) {
+  this->beginCall();
+  addPfxSourceFile_impl(pfxFilePath, pfxPassword);
+}
+void HybridImap::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 HybridImap::appendMail(const std::string& mailbox, const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  appendMail_impl(mailbox, email);
+}
+void HybridImap::appendMail_impl(const std::string& mailbox, const std::shared_ptr<HybridEmailSpec>& email) {
+  rt::checkNoNul(mailbox, "mailbox");
+  if (!this->ck().AppendMail(mailbox.c_str(), rt::implOf<HybridEmail>(email, "email").ck())) throw this->fail("appendMail");
+}
+std::shared_ptr<Promise<void>> HybridImap::appendMailAsync(const std::string& mailbox, const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(email);
+  return rt::runAsync<void>("Imap.appendMailAsync", std::move(_parts), [_self, mailbox, email]() {
+    _self->appendMail_impl(mailbox, email);
+  });
+}
+
+void HybridImap::appendMime(const std::string& mailbox, const std::string& mimeText) {
+  this->beginCall();
+  appendMime_impl(mailbox, mimeText);
+}
+void HybridImap::appendMime_impl(const std::string& mailbox, const std::string& mimeText) {
+  rt::checkNoNul(mailbox, "mailbox");
+  rt::checkNoNul(mimeText, "mimeText");
+  if (!this->ck().AppendMime(mailbox.c_str(), mimeText.c_str())) throw this->fail("appendMime");
+}
+std::shared_ptr<Promise<void>> HybridImap::appendMimeAsync(const std::string& mailbox, const std::string& mimeText) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.appendMimeAsync", std::move(_parts), [_self, mailbox, mimeText]() {
+    _self->appendMime_impl(mailbox, mimeText);
+  });
+}
+
+void HybridImap::appendMimeWithDateStr(const std::string& mailbox, const std::string& mimeText, const std::string& internalDateStr) {
+  this->beginCall();
+  appendMimeWithDateStr_impl(mailbox, mimeText, internalDateStr);
+}
+void HybridImap::appendMimeWithDateStr_impl(const std::string& mailbox, const std::string& mimeText, const std::string& internalDateStr) {
+  rt::checkNoNul(mailbox, "mailbox");
+  rt::checkNoNul(mimeText, "mimeText");
+  rt::checkNoNul(internalDateStr, "internalDateStr");
+  if (!this->ck().AppendMimeWithDateStr(mailbox.c_str(), mimeText.c_str(), internalDateStr.c_str())) throw this->fail("appendMimeWithDateStr");
+}
+std::shared_ptr<Promise<void>> HybridImap::appendMimeWithDateStrAsync(const std::string& mailbox, const std::string& mimeText, const std::string& internalDateStr) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.appendMimeWithDateStrAsync", std::move(_parts), [_self, mailbox, mimeText, internalDateStr]() {
+    _self->appendMimeWithDateStr_impl(mailbox, mimeText, internalDateStr);
+  });
+}
+
+void HybridImap::appendMimeWithFlags(const std::string& mailbox, const std::string& mimeText, bool seen, bool flagged, bool answered, bool draft) {
+  this->beginCall();
+  appendMimeWithFlags_impl(mailbox, mimeText, seen, flagged, answered, draft);
+}
+void HybridImap::appendMimeWithFlags_impl(const std::string& mailbox, const std::string& mimeText, bool seen, bool flagged, bool answered, bool draft) {
+  rt::checkNoNul(mailbox, "mailbox");
+  rt::checkNoNul(mimeText, "mimeText");
+  if (!this->ck().AppendMimeWithFlags(mailbox.c_str(), mimeText.c_str(), seen, flagged, answered, draft)) throw this->fail("appendMimeWithFlags");
+}
+std::shared_ptr<Promise<void>> HybridImap::appendMimeWithFlagsAsync(const std::string& mailbox, const std::string& mimeText, bool seen, bool flagged, bool answered, bool draft) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.appendMimeWithFlagsAsync", std::move(_parts), [_self, mailbox, mimeText, seen, flagged, answered, draft]() {
+    _self->appendMimeWithFlags_impl(mailbox, mimeText, seen, flagged, answered, draft);
+  });
+}
+
+std::string HybridImap::capability() {
+  this->beginCall();
+  return capability_impl();
+}
+std::string HybridImap::capability_impl() {
+  CkString _out;
+  if (!this->ck().Capability(_out)) throw this->fail("capability");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridImap::capabilityAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Imap.capabilityAsync", std::move(_parts), [_self]() {
+    return _self->capability_impl();
+  });
+}
+
+bool HybridImap::checkConnection() {
+  this->beginCall();
+  return checkConnection_impl();
+}
+bool HybridImap::checkConnection_impl() {
+  return this->ck().CheckConnection();
+}
+
+void HybridImap::clearSessionLog() {
+  this->beginCall();
+  clearSessionLog_impl();
+}
+void HybridImap::clearSessionLog_impl() {
+  this->ck().ClearSessionLog();
+}
+
+void HybridImap::closeMailbox(const std::string& mailbox) {
+  this->beginCall();
+  closeMailbox_impl(mailbox);
+}
+void HybridImap::closeMailbox_impl(const std::string& mailbox) {
+  rt::checkNoNul(mailbox, "mailbox");
+  if (!this->ck().CloseMailbox(mailbox.c_str())) throw this->fail("closeMailbox");
+}
+std::shared_ptr<Promise<void>> HybridImap::closeMailboxAsync(const std::string& mailbox) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.closeMailboxAsync", std::move(_parts), [_self, mailbox]() {
+    _self->closeMailbox_impl(mailbox);
+  });
+}
+
+void HybridImap::connect(const std::string& domainName) {
+  this->beginCall();
+  connect_impl(domainName);
+}
+void HybridImap::connect_impl(const std::string& domainName) {
+  rt::checkNoNul(domainName, "domainName");
+  if (!this->ck().Connect(domainName.c_str())) throw this->fail("connect");
+}
+std::shared_ptr<Promise<void>> HybridImap::connectAsync(const std::string& domainName) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.connectAsync", std::move(_parts), [_self, domainName]() {
+    _self->connect_impl(domainName);
+  });
+}
+
+void HybridImap::copy(double msgId, bool bUid, const std::string& copyToMailbox) {
+  this->beginCall();
+  copy_impl(msgId, bUid, copyToMailbox);
+}
+void HybridImap::copy_impl(double msgId, bool bUid, const std::string& copyToMailbox) {
+  rt::checkNoNul(copyToMailbox, "copyToMailbox");
+  if (!this->ck().Copy(rt::toULong(msgId, "msgId"), bUid, copyToMailbox.c_str())) throw this->fail("copy");
+}
+std::shared_ptr<Promise<void>> HybridImap::copyAsync(double msgId, bool bUid, const std::string& copyToMailbox) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.copyAsync", std::move(_parts), [_self, msgId, bUid, copyToMailbox]() {
+    _self->copy_impl(msgId, bUid, copyToMailbox);
+  });
+}
+
+void HybridImap::copyMultiple(const std::shared_ptr<HybridMessageSetSpec>& messageSet, const std::string& copyToMailbox) {
+  this->beginCall();
+  copyMultiple_impl(messageSet, copyToMailbox);
+}
+void HybridImap::copyMultiple_impl(const std::shared_ptr<HybridMessageSetSpec>& messageSet, const std::string& copyToMailbox) {
+  rt::checkNoNul(copyToMailbox, "copyToMailbox");
+  if (!this->ck().CopyMultiple(rt::implOf<HybridMessageSet>(messageSet, "messageSet").ck(), copyToMailbox.c_str())) throw this->fail("copyMultiple");
+}
+std::shared_ptr<Promise<void>> HybridImap::copyMultipleAsync(const std::shared_ptr<HybridMessageSetSpec>& messageSet, const std::string& copyToMailbox) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(messageSet);
+  return rt::runAsync<void>("Imap.copyMultipleAsync", std::move(_parts), [_self, messageSet, copyToMailbox]() {
+    _self->copyMultiple_impl(messageSet, copyToMailbox);
+  });
+}
+
+void HybridImap::copySequence(double startSeqNum, double count, const std::string& copyToMailbox) {
+  this->beginCall();
+  copySequence_impl(startSeqNum, count, copyToMailbox);
+}
+void HybridImap::copySequence_impl(double startSeqNum, double count, const std::string& copyToMailbox) {
+  rt::checkNoNul(copyToMailbox, "copyToMailbox");
+  if (!this->ck().CopySequence(rt::toInt(startSeqNum, "startSeqNum"), rt::toInt(count, "count"), copyToMailbox.c_str())) throw this->fail("copySequence");
+}
+std::shared_ptr<Promise<void>> HybridImap::copySequenceAsync(double startSeqNum, double count, const std::string& copyToMailbox) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.copySequenceAsync", std::move(_parts), [_self, startSeqNum, count, copyToMailbox]() {
+    _self->copySequence_impl(startSeqNum, count, copyToMailbox);
+  });
+}
+
+void HybridImap::createMailbox(const std::string& mailbox) {
+  this->beginCall();
+  createMailbox_impl(mailbox);
+}
+void HybridImap::createMailbox_impl(const std::string& mailbox) {
+  rt::checkNoNul(mailbox, "mailbox");
+  if (!this->ck().CreateMailbox(mailbox.c_str())) throw this->fail("createMailbox");
+}
+std::shared_ptr<Promise<void>> HybridImap::createMailboxAsync(const std::string& mailbox) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.createMailboxAsync", std::move(_parts), [_self, mailbox]() {
+    _self->createMailbox_impl(mailbox);
+  });
+}
+
+void HybridImap::deleteMailbox(const std::string& mailbox) {
+  this->beginCall();
+  deleteMailbox_impl(mailbox);
+}
+void HybridImap::deleteMailbox_impl(const std::string& mailbox) {
+  rt::checkNoNul(mailbox, "mailbox");
+  if (!this->ck().DeleteMailbox(mailbox.c_str())) throw this->fail("deleteMailbox");
+}
+std::shared_ptr<Promise<void>> HybridImap::deleteMailboxAsync(const std::string& mailbox) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.deleteMailboxAsync", std::move(_parts), [_self, mailbox]() {
+    _self->deleteMailbox_impl(mailbox);
+  });
+}
+
+void HybridImap::disconnect() {
+  this->beginCall();
+  disconnect_impl();
+}
+void HybridImap::disconnect_impl() {
+  if (!this->ck().Disconnect()) throw this->fail("disconnect");
+}
+std::shared_ptr<Promise<void>> HybridImap::disconnectAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.disconnectAsync", std::move(_parts), [_self]() {
+    _self->disconnect_impl();
+  });
+}
+
+void HybridImap::examineMailbox(const std::string& mailbox) {
+  this->beginCall();
+  examineMailbox_impl(mailbox);
+}
+void HybridImap::examineMailbox_impl(const std::string& mailbox) {
+  rt::checkNoNul(mailbox, "mailbox");
+  if (!this->ck().ExamineMailbox(mailbox.c_str())) throw this->fail("examineMailbox");
+}
+std::shared_ptr<Promise<void>> HybridImap::examineMailboxAsync(const std::string& mailbox) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.examineMailboxAsync", std::move(_parts), [_self, mailbox]() {
+    _self->examineMailbox_impl(mailbox);
+  });
+}
+
+void HybridImap::expunge() {
+  this->beginCall();
+  expunge_impl();
+}
+void HybridImap::expunge_impl() {
+  if (!this->ck().Expunge()) throw this->fail("expunge");
+}
+std::shared_ptr<Promise<void>> HybridImap::expungeAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.expungeAsync", std::move(_parts), [_self]() {
+    _self->expunge_impl();
+  });
+}
+
+void HybridImap::expungeAndClose() {
+  this->beginCall();
+  expungeAndClose_impl();
+}
+void HybridImap::expungeAndClose_impl() {
+  if (!this->ck().ExpungeAndClose()) throw this->fail("expungeAndClose");
+}
+std::shared_ptr<Promise<void>> HybridImap::expungeAndCloseAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.expungeAndCloseAsync", std::move(_parts), [_self]() {
+    _self->expungeAndClose_impl();
+  });
+}
+
+void HybridImap::fetchAttachment(const std::shared_ptr<HybridEmailSpec>& emailObject, double attachmentIndex, const std::string& saveToPath) {
+  this->beginCall();
+  fetchAttachment_impl(emailObject, attachmentIndex, saveToPath);
+}
+void HybridImap::fetchAttachment_impl(const std::shared_ptr<HybridEmailSpec>& emailObject, double attachmentIndex, const std::string& saveToPath) {
+  rt::checkNoNul(saveToPath, "saveToPath");
+  if (!this->ck().FetchAttachment(rt::implOf<HybridEmail>(emailObject, "emailObject").ck(), rt::toInt(attachmentIndex, "attachmentIndex"), saveToPath.c_str())) throw this->fail("fetchAttachment");
+}
+std::shared_ptr<Promise<void>> HybridImap::fetchAttachmentAsync(const std::shared_ptr<HybridEmailSpec>& emailObject, double attachmentIndex, const std::string& saveToPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(emailObject);
+  return rt::runAsync<void>("Imap.fetchAttachmentAsync", std::move(_parts), [_self, emailObject, attachmentIndex, saveToPath]() {
+    _self->fetchAttachment_impl(emailObject, attachmentIndex, saveToPath);
+  });
+}
+
+std::string HybridImap::fetchAttachmentString(const std::shared_ptr<HybridEmailSpec>& emailObject, double attachmentIndex, const std::string& charset) {
+  this->beginCall();
+  return fetchAttachmentString_impl(emailObject, attachmentIndex, charset);
+}
+std::string HybridImap::fetchAttachmentString_impl(const std::shared_ptr<HybridEmailSpec>& emailObject, double attachmentIndex, const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().FetchAttachmentString(rt::implOf<HybridEmail>(emailObject, "emailObject").ck(), rt::toInt(attachmentIndex, "attachmentIndex"), charset.c_str(), _out)) throw this->fail("fetchAttachmentString");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridImap::fetchAttachmentStringAsync(const std::shared_ptr<HybridEmailSpec>& emailObject, double attachmentIndex, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(emailObject);
+  return rt::runAsync<std::string>("Imap.fetchAttachmentStringAsync", std::move(_parts), [_self, emailObject, attachmentIndex, charset]() {
+    return _self->fetchAttachmentString_impl(emailObject, attachmentIndex, charset);
+  });
+}
+
+std::string HybridImap::fetchFlags(double msgId, bool bUid) {
+  this->beginCall();
+  return fetchFlags_impl(msgId, bUid);
+}
+std::string HybridImap::fetchFlags_impl(double msgId, bool bUid) {
+  CkString _out;
+  if (!this->ck().FetchFlags(rt::toULong(msgId, "msgId"), bUid, _out)) throw this->fail("fetchFlags");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridImap::fetchFlagsAsync(double msgId, bool bUid) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Imap.fetchFlagsAsync", std::move(_parts), [_self, msgId, bUid]() {
+    return _self->fetchFlags_impl(msgId, bUid);
+  });
+}
+
+std::string HybridImap::fetchSingleAsMime(double msgId, bool bUid) {
+  this->beginCall();
+  return fetchSingleAsMime_impl(msgId, bUid);
+}
+std::string HybridImap::fetchSingleAsMime_impl(double msgId, bool bUid) {
+  CkString _out;
+  if (!this->ck().FetchSingleAsMime(rt::toULong(msgId, "msgId"), bUid, _out)) throw this->fail("fetchSingleAsMime");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridImap::fetchSingleAsMimeAsync(double msgId, bool bUid) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Imap.fetchSingleAsMimeAsync", std::move(_parts), [_self, msgId, bUid]() {
+    return _self->fetchSingleAsMime_impl(msgId, bUid);
+  });
+}
+
+std::string HybridImap::fetchSingleHeaderAsMime(double msgId, bool bUID) {
+  this->beginCall();
+  return fetchSingleHeaderAsMime_impl(msgId, bUID);
+}
+std::string HybridImap::fetchSingleHeaderAsMime_impl(double msgId, bool bUID) {
+  CkString _out;
+  if (!this->ck().FetchSingleHeaderAsMime(rt::toULong(msgId, "msgId"), bUID, _out)) throw this->fail("fetchSingleHeaderAsMime");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridImap::fetchSingleHeaderAsMimeAsync(double msgId, bool bUID) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Imap.fetchSingleHeaderAsMimeAsync", std::move(_parts), [_self, msgId, bUID]() {
+    return _self->fetchSingleHeaderAsMime_impl(msgId, bUID);
+  });
+}
+
+std::string HybridImap::getMailAttachFilename(const std::shared_ptr<HybridEmailSpec>& email, double attachIndex) {
+  this->beginCall();
+  return getMailAttachFilename_impl(email, attachIndex);
+}
+std::string HybridImap::getMailAttachFilename_impl(const std::shared_ptr<HybridEmailSpec>& email, double attachIndex) {
+  CkString _out;
+  if (!this->ck().GetMailAttachFilename(rt::implOf<HybridEmail>(email, "email").ck(), rt::toInt(attachIndex, "attachIndex"), _out)) throw this->fail("getMailAttachFilename");
+  return rt::stdString(_out);
+}
+
+double HybridImap::getMailAttachSize(const std::shared_ptr<HybridEmailSpec>& email, double attachIndex) {
+  this->beginCall();
+  return getMailAttachSize_impl(email, attachIndex);
+}
+double HybridImap::getMailAttachSize_impl(const std::shared_ptr<HybridEmailSpec>& email, double attachIndex) {
+  return static_cast<double>(this->ck().GetMailAttachSize(rt::implOf<HybridEmail>(email, "email").ck(), rt::toInt(attachIndex, "attachIndex")));
+}
+
+double HybridImap::getMailFlag(const std::shared_ptr<HybridEmailSpec>& email, const std::string& flagName) {
+  this->beginCall();
+  return getMailFlag_impl(email, flagName);
+}
+double HybridImap::getMailFlag_impl(const std::shared_ptr<HybridEmailSpec>& email, const std::string& flagName) {
+  rt::checkNoNul(flagName, "flagName");
+  return static_cast<double>(this->ck().GetMailFlag(rt::implOf<HybridEmail>(email, "email").ck(), flagName.c_str()));
+}
+
+double HybridImap::getMailNumAttach(const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  return getMailNumAttach_impl(email);
+}
+double HybridImap::getMailNumAttach_impl(const std::shared_ptr<HybridEmailSpec>& email) {
+  return static_cast<double>(this->ck().GetMailNumAttach(rt::implOf<HybridEmail>(email, "email").ck()));
+}
+
+double HybridImap::getMailSize(const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  return getMailSize_impl(email);
+}
+double HybridImap::getMailSize_impl(const std::shared_ptr<HybridEmailSpec>& email) {
+  return static_cast<double>(this->ck().GetMailSize(rt::implOf<HybridEmail>(email, "email").ck()));
+}
+
+std::string HybridImap::getMailboxStatus(const std::string& mailbox) {
+  this->beginCall();
+  return getMailboxStatus_impl(mailbox);
+}
+std::string HybridImap::getMailboxStatus_impl(const std::string& mailbox) {
+  rt::checkNoNul(mailbox, "mailbox");
+  CkString _out;
+  if (!this->ck().GetMailboxStatus(mailbox.c_str(), _out)) throw this->fail("getMailboxStatus");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridImap::getMailboxStatusAsync(const std::string& mailbox) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Imap.getMailboxStatusAsync", std::move(_parts), [_self, mailbox]() {
+    return _self->getMailboxStatus_impl(mailbox);
+  });
+}
+
+std::string HybridImap::getQuota(const std::string& quotaRoot) {
+  this->beginCall();
+  return getQuota_impl(quotaRoot);
+}
+std::string HybridImap::getQuota_impl(const std::string& quotaRoot) {
+  rt::checkNoNul(quotaRoot, "quotaRoot");
+  CkString _out;
+  if (!this->ck().GetQuota(quotaRoot.c_str(), _out)) throw this->fail("getQuota");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridImap::getQuotaAsync(const std::string& quotaRoot) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Imap.getQuotaAsync", std::move(_parts), [_self, quotaRoot]() {
+    return _self->getQuota_impl(quotaRoot);
+  });
+}
+
+std::string HybridImap::getQuotaRoot(const std::string& mailboxName) {
+  this->beginCall();
+  return getQuotaRoot_impl(mailboxName);
+}
+std::string HybridImap::getQuotaRoot_impl(const std::string& mailboxName) {
+  rt::checkNoNul(mailboxName, "mailboxName");
+  CkString _out;
+  if (!this->ck().GetQuotaRoot(mailboxName.c_str(), _out)) throw this->fail("getQuotaRoot");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridImap::getQuotaRootAsync(const std::string& mailboxName) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Imap.getQuotaRootAsync", std::move(_parts), [_self, mailboxName]() {
+    return _self->getQuotaRoot_impl(mailboxName);
+  });
+}
+
+bool HybridImap::hasCapability(const std::string& name, const std::string& capabilityResponse) {
+  this->beginCall();
+  return hasCapability_impl(name, capabilityResponse);
+}
+bool HybridImap::hasCapability_impl(const std::string& name, const std::string& capabilityResponse) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(capabilityResponse, "capabilityResponse");
+  return this->ck().HasCapability(name.c_str(), capabilityResponse.c_str());
+}
+
+std::string HybridImap::idleCheck(double timeoutMs) {
+  this->beginCall();
+  return idleCheck_impl(timeoutMs);
+}
+std::string HybridImap::idleCheck_impl(double timeoutMs) {
+  CkString _out;
+  if (!this->ck().IdleCheck(rt::toInt(timeoutMs, "timeoutMs"), _out)) throw this->fail("idleCheck");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridImap::idleCheckAsync(double timeoutMs) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Imap.idleCheckAsync", std::move(_parts), [_self, timeoutMs]() {
+    return _self->idleCheck_impl(timeoutMs);
+  });
+}
+
+void HybridImap::idleDone() {
+  this->beginCall();
+  idleDone_impl();
+}
+void HybridImap::idleDone_impl() {
+  if (!this->ck().IdleDone()) throw this->fail("idleDone");
+}
+std::shared_ptr<Promise<void>> HybridImap::idleDoneAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.idleDoneAsync", std::move(_parts), [_self]() {
+    _self->idleDone_impl();
+  });
+}
+
+void HybridImap::idleStart() {
+  this->beginCall();
+  idleStart_impl();
+}
+void HybridImap::idleStart_impl() {
+  if (!this->ck().IdleStart()) throw this->fail("idleStart");
+}
+std::shared_ptr<Promise<void>> HybridImap::idleStartAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.idleStartAsync", std::move(_parts), [_self]() {
+    _self->idleStart_impl();
+  });
+}
+
+bool HybridImap::isConnected() {
+  this->beginCall();
+  return isConnected_impl();
+}
+bool HybridImap::isConnected_impl() {
+  return this->ck().IsConnected();
+}
+
+bool HybridImap::isLoggedIn() {
+  this->beginCall();
+  return isLoggedIn_impl();
+}
+bool HybridImap::isLoggedIn_impl() {
+  return this->ck().IsLoggedIn();
+}
+
+void HybridImap::login(const std::string& loginName, const std::string& password) {
+  this->beginCall();
+  login_impl(loginName, password);
+}
+void HybridImap::login_impl(const std::string& loginName, const std::string& password) {
+  rt::checkNoNul(loginName, "loginName");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().Login(loginName.c_str(), password.c_str())) throw this->fail("login");
+}
+std::shared_ptr<Promise<void>> HybridImap::loginAsync(const std::string& loginName, const std::string& password) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.loginAsync", std::move(_parts), [_self, loginName, password]() {
+    _self->login_impl(loginName, password);
+  });
+}
+
+void HybridImap::logout() {
+  this->beginCall();
+  logout_impl();
+}
+void HybridImap::logout_impl() {
+  if (!this->ck().Logout()) throw this->fail("logout");
+}
+std::shared_ptr<Promise<void>> HybridImap::logoutAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.logoutAsync", std::move(_parts), [_self]() {
+    _self->logout_impl();
+  });
+}
+
+void HybridImap::noop() {
+  this->beginCall();
+  noop_impl();
+}
+void HybridImap::noop_impl() {
+  if (!this->ck().Noop()) throw this->fail("noop");
+}
+std::shared_ptr<Promise<void>> HybridImap::noopAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.noopAsync", std::move(_parts), [_self]() {
+    _self->noop_impl();
+  });
+}
+
+void HybridImap::refetchMailFlags(const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  refetchMailFlags_impl(email);
+}
+void HybridImap::refetchMailFlags_impl(const std::shared_ptr<HybridEmailSpec>& email) {
+  if (!this->ck().RefetchMailFlags(rt::implOf<HybridEmail>(email, "email").ck())) throw this->fail("refetchMailFlags");
+}
+std::shared_ptr<Promise<void>> HybridImap::refetchMailFlagsAsync(const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(email);
+  return rt::runAsync<void>("Imap.refetchMailFlagsAsync", std::move(_parts), [_self, email]() {
+    _self->refetchMailFlags_impl(email);
+  });
+}
+
+void HybridImap::renameMailbox(const std::string& fromMailbox, const std::string& toMailbox) {
+  this->beginCall();
+  renameMailbox_impl(fromMailbox, toMailbox);
+}
+void HybridImap::renameMailbox_impl(const std::string& fromMailbox, const std::string& toMailbox) {
+  rt::checkNoNul(fromMailbox, "fromMailbox");
+  rt::checkNoNul(toMailbox, "toMailbox");
+  if (!this->ck().RenameMailbox(fromMailbox.c_str(), toMailbox.c_str())) throw this->fail("renameMailbox");
+}
+std::shared_ptr<Promise<void>> HybridImap::renameMailboxAsync(const std::string& fromMailbox, const std::string& toMailbox) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.renameMailboxAsync", std::move(_parts), [_self, fromMailbox, toMailbox]() {
+    _self->renameMailbox_impl(fromMailbox, toMailbox);
+  });
+}
+
+void HybridImap::selectMailbox(const std::string& mailbox) {
+  this->beginCall();
+  selectMailbox_impl(mailbox);
+}
+void HybridImap::selectMailbox_impl(const std::string& mailbox) {
+  rt::checkNoNul(mailbox, "mailbox");
+  if (!this->ck().SelectMailbox(mailbox.c_str())) throw this->fail("selectMailbox");
+}
+std::shared_ptr<Promise<void>> HybridImap::selectMailboxAsync(const std::string& mailbox) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.selectMailboxAsync", std::move(_parts), [_self, mailbox]() {
+    _self->selectMailbox_impl(mailbox);
+  });
+}
+
+std::string HybridImap::sendRawCommand(const std::string& cmd) {
+  this->beginCall();
+  return sendRawCommand_impl(cmd);
+}
+std::string HybridImap::sendRawCommand_impl(const std::string& cmd) {
+  rt::checkNoNul(cmd, "cmd");
+  CkString _out;
+  if (!this->ck().SendRawCommand(cmd.c_str(), _out)) throw this->fail("sendRawCommand");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridImap::sendRawCommandAsync(const std::string& cmd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Imap.sendRawCommandAsync", std::move(_parts), [_self, cmd]() {
+    return _self->sendRawCommand_impl(cmd);
+  });
+}
+
+void HybridImap::setDecryptCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setDecryptCert_impl(cert);
+}
+void HybridImap::setDecryptCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetDecryptCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setDecryptCert");
+}
+
+void HybridImap::setDecryptCert2(const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridPrivateKeySpec>& key) {
+  this->beginCall();
+  setDecryptCert2_impl(cert, key);
+}
+void HybridImap::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 HybridImap::setFlag(double msgId, bool bUid, const std::string& flagName, double value) {
+  this->beginCall();
+  setFlag_impl(msgId, bUid, flagName, value);
+}
+void HybridImap::setFlag_impl(double msgId, bool bUid, const std::string& flagName, double value) {
+  rt::checkNoNul(flagName, "flagName");
+  if (!this->ck().SetFlag(rt::toULong(msgId, "msgId"), bUid, flagName.c_str(), rt::toInt(value, "value"))) throw this->fail("setFlag");
+}
+std::shared_ptr<Promise<void>> HybridImap::setFlagAsync(double msgId, bool bUid, const std::string& flagName, double value) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.setFlagAsync", std::move(_parts), [_self, msgId, bUid, flagName, value]() {
+    _self->setFlag_impl(msgId, bUid, flagName, value);
+  });
+}
+
+void HybridImap::setFlags(const std::shared_ptr<HybridMessageSetSpec>& messageSet, const std::string& flagName, double value) {
+  this->beginCall();
+  setFlags_impl(messageSet, flagName, value);
+}
+void HybridImap::setFlags_impl(const std::shared_ptr<HybridMessageSetSpec>& messageSet, const std::string& flagName, double value) {
+  rt::checkNoNul(flagName, "flagName");
+  if (!this->ck().SetFlags(rt::implOf<HybridMessageSet>(messageSet, "messageSet").ck(), flagName.c_str(), rt::toInt(value, "value"))) throw this->fail("setFlags");
+}
+std::shared_ptr<Promise<void>> HybridImap::setFlagsAsync(const std::shared_ptr<HybridMessageSetSpec>& messageSet, const std::string& flagName, double value) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(messageSet);
+  return rt::runAsync<void>("Imap.setFlagsAsync", std::move(_parts), [_self, messageSet, flagName, value]() {
+    _self->setFlags_impl(messageSet, flagName, value);
+  });
+}
+
+void HybridImap::setMailFlag(const std::shared_ptr<HybridEmailSpec>& email, const std::string& flagName, double value) {
+  this->beginCall();
+  setMailFlag_impl(email, flagName, value);
+}
+void HybridImap::setMailFlag_impl(const std::shared_ptr<HybridEmailSpec>& email, const std::string& flagName, double value) {
+  rt::checkNoNul(flagName, "flagName");
+  if (!this->ck().SetMailFlag(rt::implOf<HybridEmail>(email, "email").ck(), flagName.c_str(), rt::toInt(value, "value"))) throw this->fail("setMailFlag");
+}
+std::shared_ptr<Promise<void>> HybridImap::setMailFlagAsync(const std::shared_ptr<HybridEmailSpec>& email, const std::string& flagName, double value) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(email);
+  return rt::runAsync<void>("Imap.setMailFlagAsync", std::move(_parts), [_self, email, flagName, value]() {
+    _self->setMailFlag_impl(email, flagName, value);
+  });
+}
+
+void HybridImap::setQuota(const std::string& quotaRoot, const std::string& resource, double quota) {
+  this->beginCall();
+  setQuota_impl(quotaRoot, resource, quota);
+}
+void HybridImap::setQuota_impl(const std::string& quotaRoot, const std::string& resource, double quota) {
+  rt::checkNoNul(quotaRoot, "quotaRoot");
+  rt::checkNoNul(resource, "resource");
+  if (!this->ck().SetQuota(quotaRoot.c_str(), resource.c_str(), rt::toInt(quota, "quota"))) throw this->fail("setQuota");
+}
+std::shared_ptr<Promise<void>> HybridImap::setQuotaAsync(const std::string& quotaRoot, const std::string& resource, double quota) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.setQuotaAsync", std::move(_parts), [_self, quotaRoot, resource, quota]() {
+    _self->setQuota_impl(quotaRoot, resource, quota);
+  });
+}
+
+void HybridImap::setSslClientCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setSslClientCert_impl(cert);
+}
+void HybridImap::setSslClientCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetSslClientCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setSslClientCert");
+}
+
+void HybridImap::setSslClientCertPem(const std::string& pemDataOrFilename, const std::string& pemPassword) {
+  this->beginCall();
+  setSslClientCertPem_impl(pemDataOrFilename, pemPassword);
+}
+void HybridImap::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 HybridImap::setSslClientCertPfx(const std::string& pfxFilename, const std::string& pfxPassword) {
+  this->beginCall();
+  setSslClientCertPfx_impl(pfxFilename, pfxPassword);
+}
+void HybridImap::setSslClientCertPfx_impl(const std::string& pfxFilename, const std::string& pfxPassword) {
+  rt::checkNoNul(pfxFilename, "pfxFilename");
+  rt::checkNoNul(pfxPassword, "pfxPassword");
+  if (!this->ck().SetSslClientCertPfx(pfxFilename.c_str(), pfxPassword.c_str())) throw this->fail("setSslClientCertPfx");
+}
+
+void HybridImap::sshAuthenticatePk(const std::string& sshLogin, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  sshAuthenticatePk_impl(sshLogin, privateKey);
+}
+void HybridImap::sshAuthenticatePk_impl(const std::string& sshLogin, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  rt::checkNoNul(sshLogin, "sshLogin");
+  if (!this->ck().SshAuthenticatePk(sshLogin.c_str(), rt::implOf<HybridSshKey>(privateKey, "privateKey").ck())) throw this->fail("sshAuthenticatePk");
+}
+std::shared_ptr<Promise<void>> HybridImap::sshAuthenticatePkAsync(const std::string& sshLogin, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(privateKey);
+  return rt::runAsync<void>("Imap.sshAuthenticatePkAsync", std::move(_parts), [_self, sshLogin, privateKey]() {
+    _self->sshAuthenticatePk_impl(sshLogin, privateKey);
+  });
+}
+
+void HybridImap::sshAuthenticatePw(const std::string& sshLogin, const std::string& sshPassword) {
+  this->beginCall();
+  sshAuthenticatePw_impl(sshLogin, sshPassword);
+}
+void HybridImap::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>> HybridImap::sshAuthenticatePwAsync(const std::string& sshLogin, const std::string& sshPassword) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.sshAuthenticatePwAsync", std::move(_parts), [_self, sshLogin, sshPassword]() {
+    _self->sshAuthenticatePw_impl(sshLogin, sshPassword);
+  });
+}
+
+void HybridImap::sshCloseTunnel() {
+  this->beginCall();
+  sshCloseTunnel_impl();
+}
+void HybridImap::sshCloseTunnel_impl() {
+  if (!this->ck().SshCloseTunnel()) throw this->fail("sshCloseTunnel");
+}
+std::shared_ptr<Promise<void>> HybridImap::sshCloseTunnelAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.sshCloseTunnelAsync", std::move(_parts), [_self]() {
+    _self->sshCloseTunnel_impl();
+  });
+}
+
+void HybridImap::sshOpenTunnel(const std::string& sshHostname, double sshPort) {
+  this->beginCall();
+  sshOpenTunnel_impl(sshHostname, sshPort);
+}
+void HybridImap::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>> HybridImap::sshOpenTunnelAsync(const std::string& sshHostname, double sshPort) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.sshOpenTunnelAsync", std::move(_parts), [_self, sshHostname, sshPort]() {
+    _self->sshOpenTunnel_impl(sshHostname, sshPort);
+  });
+}
+
+void HybridImap::storeFlags(double msgId, bool bUid, const std::string& flagNames, double value) {
+  this->beginCall();
+  storeFlags_impl(msgId, bUid, flagNames, value);
+}
+void HybridImap::storeFlags_impl(double msgId, bool bUid, const std::string& flagNames, double value) {
+  rt::checkNoNul(flagNames, "flagNames");
+  if (!this->ck().StoreFlags(rt::toULong(msgId, "msgId"), bUid, flagNames.c_str(), rt::toInt(value, "value"))) throw this->fail("storeFlags");
+}
+std::shared_ptr<Promise<void>> HybridImap::storeFlagsAsync(double msgId, bool bUid, const std::string& flagNames, double value) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.storeFlagsAsync", std::move(_parts), [_self, msgId, bUid, flagNames, value]() {
+    _self->storeFlags_impl(msgId, bUid, flagNames, value);
+  });
+}
+
+void HybridImap::subscribe(const std::string& mailbox) {
+  this->beginCall();
+  subscribe_impl(mailbox);
+}
+void HybridImap::subscribe_impl(const std::string& mailbox) {
+  rt::checkNoNul(mailbox, "mailbox");
+  if (!this->ck().Subscribe(mailbox.c_str())) throw this->fail("subscribe");
+}
+std::shared_ptr<Promise<void>> HybridImap::subscribeAsync(const std::string& mailbox) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.subscribeAsync", std::move(_parts), [_self, mailbox]() {
+    _self->subscribe_impl(mailbox);
+  });
+}
+
+void HybridImap::unsubscribe(const std::string& mailbox) {
+  this->beginCall();
+  unsubscribe_impl(mailbox);
+}
+void HybridImap::unsubscribe_impl(const std::string& mailbox) {
+  rt::checkNoNul(mailbox, "mailbox");
+  if (!this->ck().Unsubscribe(mailbox.c_str())) throw this->fail("unsubscribe");
+}
+std::shared_ptr<Promise<void>> HybridImap::unsubscribeAsync(const std::string& mailbox) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Imap.unsubscribeAsync", std::move(_parts), [_self, mailbox]() {
+    _self->unsubscribe_impl(mailbox);
+  });
+}
+
+void HybridImap::useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  this->beginCall();
+  useCertVault_impl(vault);
+}
+void HybridImap::useCertVault_impl(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  if (!this->ck().UseCertVault(rt::implOf<HybridXmlCertVault>(vault, "vault").ck())) throw this->fail("useCertVault");
+}
+
+void HybridImap::useSsh(const std::shared_ptr<HybridSshSpec>& ssh) {
+  this->beginCall();
+  useSsh_impl(ssh);
+}
+void HybridImap::useSsh_impl(const std::shared_ptr<HybridSshSpec>& ssh) {
+  if (!this->ck().UseSsh(rt::implOf<HybridSsh>(ssh, "ssh").ck())) throw this->fail("useSsh");
+}
+
+void HybridImap::useSshTunnel(const std::shared_ptr<HybridSocketSpec>& tunnel) {
+  this->beginCall();
+  useSshTunnel_impl(tunnel);
+}
+void HybridImap::useSshTunnel_impl(const std::shared_ptr<HybridSocketSpec>& tunnel) {
+  if (!this->ck().UseSshTunnel(rt::implOf<HybridSocket>(tunnel, "tunnel").ck())) throw this->fail("useSshTunnel");
+}
+
+void HybridImap::fetchSingleAsMimeSb(double msgId, bool bUid, const std::shared_ptr<HybridStringBuilderSpec>& sbMime) {
+  this->beginCall();
+  fetchSingleAsMimeSb_impl(msgId, bUid, sbMime);
+}
+void HybridImap::fetchSingleAsMimeSb_impl(double msgId, bool bUid, const std::shared_ptr<HybridStringBuilderSpec>& sbMime) {
+  if (!this->ck().FetchSingleAsMimeSb(rt::toULong(msgId, "msgId"), bUid, rt::implOf<HybridStringBuilder>(sbMime, "sbMime").ck())) throw this->fail("fetchSingleAsMimeSb");
+}
+std::shared_ptr<Promise<void>> HybridImap::fetchSingleAsMimeSbAsync(double msgId, bool bUid, const std::shared_ptr<HybridStringBuilderSpec>& sbMime) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sbMime);
+  return rt::runAsync<void>("Imap.fetchSingleAsMimeSbAsync", std::move(_parts), [_self, msgId, bUid, sbMime]() {
+    _self->fetchSingleAsMimeSb_impl(msgId, bUid, sbMime);
+  });
+}
+
+void HybridImap::fetchAttachmentSb(const std::shared_ptr<HybridEmailSpec>& email, double attachmentIndex, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  fetchAttachmentSb_impl(email, attachmentIndex, charset, sb);
+}
+void HybridImap::fetchAttachmentSb_impl(const std::shared_ptr<HybridEmailSpec>& email, double attachmentIndex, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().FetchAttachmentSb(rt::implOf<HybridEmail>(email, "email").ck(), rt::toInt(attachmentIndex, "attachmentIndex"), charset.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("fetchAttachmentSb");
+}
+std::shared_ptr<Promise<void>> HybridImap::fetchAttachmentSbAsync(const std::shared_ptr<HybridEmailSpec>& email, double attachmentIndex, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(email);
+  _parts.push_back(sb);
+  return rt::runAsync<void>("Imap.fetchAttachmentSbAsync", std::move(_parts), [_self, email, attachmentIndex, charset, sb]() {
+    _self->fetchAttachmentSb_impl(email, attachmentIndex, charset, sb);
+  });
+}
+
+void HybridImap::fetchAttachmentBd(const std::shared_ptr<HybridEmailSpec>& email, double attachmentIndex, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  fetchAttachmentBd_impl(email, attachmentIndex, binData);
+}
+void HybridImap::fetchAttachmentBd_impl(const std::shared_ptr<HybridEmailSpec>& email, double attachmentIndex, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().FetchAttachmentBd(rt::implOf<HybridEmail>(email, "email").ck(), rt::toInt(attachmentIndex, "attachmentIndex"), rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("fetchAttachmentBd");
+}
+std::shared_ptr<Promise<void>> HybridImap::fetchAttachmentBdAsync(const std::shared_ptr<HybridEmailSpec>& email, double attachmentIndex, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(email);
+  _parts.push_back(binData);
+  return rt::runAsync<void>("Imap.fetchAttachmentBdAsync", std::move(_parts), [_self, email, attachmentIndex, binData]() {
+    _self->fetchAttachmentBd_impl(email, attachmentIndex, binData);
+  });
+}
+
+void HybridImap::appendMimeWithFlagsSb(const std::string& mailbox, const std::shared_ptr<HybridStringBuilderSpec>& sbMime, bool seen, bool flagged, bool answered, bool draft) {
+  this->beginCall();
+  appendMimeWithFlagsSb_impl(mailbox, sbMime, seen, flagged, answered, draft);
+}
+void HybridImap::appendMimeWithFlagsSb_impl(const std::string& mailbox, const std::shared_ptr<HybridStringBuilderSpec>& sbMime, bool seen, bool flagged, bool answered, bool draft) {
+  rt::checkNoNul(mailbox, "mailbox");
+  if (!this->ck().AppendMimeWithFlagsSb(mailbox.c_str(), rt::implOf<HybridStringBuilder>(sbMime, "sbMime").ck(), seen, flagged, answered, draft)) throw this->fail("appendMimeWithFlagsSb");
+}
+std::shared_ptr<Promise<void>> HybridImap::appendMimeWithFlagsSbAsync(const std::string& mailbox, const std::shared_ptr<HybridStringBuilderSpec>& sbMime, bool seen, bool flagged, bool answered, bool draft) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sbMime);
+  return rt::runAsync<void>("Imap.appendMimeWithFlagsSbAsync", std::move(_parts), [_self, mailbox, sbMime, seen, flagged, answered, draft]() {
+    _self->appendMimeWithFlagsSb_impl(mailbox, sbMime, seen, flagged, answered, draft);
+  });
+}
+
+void HybridImap::moveMessages(const std::shared_ptr<HybridMessageSetSpec>& messageSet, const std::string& destFolder) {
+  this->beginCall();
+  moveMessages_impl(messageSet, destFolder);
+}
+void HybridImap::moveMessages_impl(const std::shared_ptr<HybridMessageSetSpec>& messageSet, const std::string& destFolder) {
+  rt::checkNoNul(destFolder, "destFolder");
+  if (!this->ck().MoveMessages(rt::implOf<HybridMessageSet>(messageSet, "messageSet").ck(), destFolder.c_str())) throw this->fail("moveMessages");
+}
+std::shared_ptr<Promise<void>> HybridImap::moveMessagesAsync(const std::shared_ptr<HybridMessageSetSpec>& messageSet, const std::string& destFolder) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(messageSet);
+  return rt::runAsync<void>("Imap.moveMessagesAsync", std::move(_parts), [_self, messageSet, destFolder]() {
+    _self->moveMessages_impl(messageSet, destFolder);
+  });
+}
+
+void HybridImap::loginSecure(const std::shared_ptr<HybridSecureStringSpec>& loginName, const std::shared_ptr<HybridSecureStringSpec>& password) {
+  this->beginCall();
+  loginSecure_impl(loginName, password);
+}
+void HybridImap::loginSecure_impl(const std::shared_ptr<HybridSecureStringSpec>& loginName, const std::shared_ptr<HybridSecureStringSpec>& password) {
+  if (!this->ck().LoginSecure(rt::implOf<HybridSecureString>(loginName, "loginName").ck(), rt::implOf<HybridSecureString>(password, "password").ck())) throw this->fail("loginSecure");
+}
+std::shared_ptr<Promise<void>> HybridImap::loginSecureAsync(const std::shared_ptr<HybridSecureStringSpec>& loginName, const std::shared_ptr<HybridSecureStringSpec>& password) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(loginName);
+  _parts.push_back(password);
+  return rt::runAsync<void>("Imap.loginSecureAsync", std::move(_parts), [_self, loginName, password]() {
+    _self->loginSecure_impl(loginName, password);
+  });
+}
+
+void HybridImap::fetchSingleBd(double msgId, bool bUid, const std::shared_ptr<HybridBinDataSpec>& mimeData) {
+  this->beginCall();
+  fetchSingleBd_impl(msgId, bUid, mimeData);
+}
+void HybridImap::fetchSingleBd_impl(double msgId, bool bUid, const std::shared_ptr<HybridBinDataSpec>& mimeData) {
+  if (!this->ck().FetchSingleBd(rt::toULong(msgId, "msgId"), bUid, rt::implOf<HybridBinData>(mimeData, "mimeData").ck())) throw this->fail("fetchSingleBd");
+}
+std::shared_ptr<Promise<void>> HybridImap::fetchSingleBdAsync(double msgId, bool bUid, const std::shared_ptr<HybridBinDataSpec>& mimeData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(mimeData);
+  return rt::runAsync<void>("Imap.fetchSingleBdAsync", std::move(_parts), [_self, msgId, bUid, mimeData]() {
+    _self->fetchSingleBd_impl(msgId, bUid, mimeData);
+  });
+}
+
+void HybridImap::getServerCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  getServerCert_impl(cert);
+}
+void HybridImap::getServerCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().GetServerCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("getServerCert");
+}
+
+void HybridImap::fetchMsgSet(bool headersOnly, const std::shared_ptr<HybridMessageSetSpec>& msgSet, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  this->beginCall();
+  fetchMsgSet_impl(headersOnly, msgSet, bundle);
+}
+void HybridImap::fetchMsgSet_impl(bool headersOnly, const std::shared_ptr<HybridMessageSetSpec>& msgSet, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  if (!this->ck().FetchMsgSet(headersOnly, rt::implOf<HybridMessageSet>(msgSet, "msgSet").ck(), rt::implOf<HybridEmailBundle>(bundle, "bundle").ck())) throw this->fail("fetchMsgSet");
+}
+std::shared_ptr<Promise<void>> HybridImap::fetchMsgSetAsync(bool headersOnly, const std::shared_ptr<HybridMessageSetSpec>& msgSet, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(msgSet);
+  _parts.push_back(bundle);
+  return rt::runAsync<void>("Imap.fetchMsgSetAsync", std::move(_parts), [_self, headersOnly, msgSet, bundle]() {
+    _self->fetchMsgSet_impl(headersOnly, msgSet, bundle);
+  });
+}
+
+void HybridImap::fetchRange(bool headersOnly, double seqnum, double count, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  this->beginCall();
+  fetchRange_impl(headersOnly, seqnum, count, bundle);
+}
+void HybridImap::fetchRange_impl(bool headersOnly, double seqnum, double count, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  if (!this->ck().FetchRange(headersOnly, rt::toInt(seqnum, "seqnum"), rt::toInt(count, "count"), rt::implOf<HybridEmailBundle>(bundle, "bundle").ck())) throw this->fail("fetchRange");
+}
+std::shared_ptr<Promise<void>> HybridImap::fetchRangeAsync(bool headersOnly, double seqnum, double count, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bundle);
+  return rt::runAsync<void>("Imap.fetchRangeAsync", std::move(_parts), [_self, headersOnly, seqnum, count, bundle]() {
+    _self->fetchRange_impl(headersOnly, seqnum, count, bundle);
+  });
+}
+
+void HybridImap::fetchEmail(bool headerOnly, double msgId, bool bUid, const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  fetchEmail_impl(headerOnly, msgId, bUid, email);
+}
+void HybridImap::fetchEmail_impl(bool headerOnly, double msgId, bool bUid, const std::shared_ptr<HybridEmailSpec>& email) {
+  if (!this->ck().FetchEmail(headerOnly, rt::toULong(msgId, "msgId"), bUid, rt::implOf<HybridEmail>(email, "email").ck())) throw this->fail("fetchEmail");
+}
+std::shared_ptr<Promise<void>> HybridImap::fetchEmailAsync(bool headerOnly, double msgId, bool bUid, const std::shared_ptr<HybridEmailSpec>& email) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(email);
+  return rt::runAsync<void>("Imap.fetchEmailAsync", std::move(_parts), [_self, headerOnly, msgId, bUid, email]() {
+    _self->fetchEmail_impl(headerOnly, msgId, bUid, email);
+  });
+}
+
+void HybridImap::mbxList(bool subscribed, const std::string& reference, const std::string& mbxPattern, const std::shared_ptr<HybridMailboxesSpec>& mboxes) {
+  this->beginCall();
+  mbxList_impl(subscribed, reference, mbxPattern, mboxes);
+}
+void HybridImap::mbxList_impl(bool subscribed, const std::string& reference, const std::string& mbxPattern, const std::shared_ptr<HybridMailboxesSpec>& mboxes) {
+  rt::checkNoNul(reference, "reference");
+  rt::checkNoNul(mbxPattern, "mbxPattern");
+  if (!this->ck().MbxList(subscribed, reference.c_str(), mbxPattern.c_str(), rt::implOf<HybridMailboxes>(mboxes, "mboxes").ck())) throw this->fail("mbxList");
+}
+std::shared_ptr<Promise<void>> HybridImap::mbxListAsync(bool subscribed, const std::string& reference, const std::string& mbxPattern, const std::shared_ptr<HybridMailboxesSpec>& mboxes) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(mboxes);
+  return rt::runAsync<void>("Imap.mbxListAsync", std::move(_parts), [_self, subscribed, reference, mbxPattern, mboxes]() {
+    _self->mbxList_impl(subscribed, reference, mbxPattern, mboxes);
+  });
+}
+
+void HybridImap::queryMbx(const std::string& criteria, bool bUid, const std::shared_ptr<HybridMessageSetSpec>& msgSet) {
+  this->beginCall();
+  queryMbx_impl(criteria, bUid, msgSet);
+}
+void HybridImap::queryMbx_impl(const std::string& criteria, bool bUid, const std::shared_ptr<HybridMessageSetSpec>& msgSet) {
+  rt::checkNoNul(criteria, "criteria");
+  if (!this->ck().QueryMbx(criteria.c_str(), bUid, rt::implOf<HybridMessageSet>(msgSet, "msgSet").ck())) throw this->fail("queryMbx");
+}
+std::shared_ptr<Promise<void>> HybridImap::queryMbxAsync(const std::string& criteria, bool bUid, const std::shared_ptr<HybridMessageSetSpec>& msgSet) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(msgSet);
+  return rt::runAsync<void>("Imap.queryMbxAsync", std::move(_parts), [_self, criteria, bUid, msgSet]() {
+    _self->queryMbx_impl(criteria, bUid, msgSet);
+  });
+}
+
+void HybridImap::fetchChunk2(double seqnum, double count, const std::shared_ptr<HybridMessageSetSpec>& failedSet, const std::shared_ptr<HybridMessageSetSpec>& fetchedSet, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  this->beginCall();
+  fetchChunk2_impl(seqnum, count, failedSet, fetchedSet, bundle);
+}
+void HybridImap::fetchChunk2_impl(double seqnum, double count, const std::shared_ptr<HybridMessageSetSpec>& failedSet, const std::shared_ptr<HybridMessageSetSpec>& fetchedSet, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  if (!this->ck().FetchChunk2(rt::toInt(seqnum, "seqnum"), rt::toInt(count, "count"), rt::implOf<HybridMessageSet>(failedSet, "failedSet").ck(), rt::implOf<HybridMessageSet>(fetchedSet, "fetchedSet").ck(), rt::implOf<HybridEmailBundle>(bundle, "bundle").ck())) throw this->fail("fetchChunk2");
+}
+std::shared_ptr<Promise<void>> HybridImap::fetchChunk2Async(double seqnum, double count, const std::shared_ptr<HybridMessageSetSpec>& failedSet, const std::shared_ptr<HybridMessageSetSpec>& fetchedSet, const std::shared_ptr<HybridEmailBundleSpec>& bundle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(failedSet);
+  _parts.push_back(fetchedSet);
+  _parts.push_back(bundle);
+  return rt::runAsync<void>("Imap.fetchChunk2Async", std::move(_parts), [_self, seqnum, count, failedSet, fetchedSet, bundle]() {
+    _self->fetchChunk2_impl(seqnum, count, failedSet, fetchedSet, bundle);
+  });
+}
+
+void HybridImap::queryThread(const std::string& threadAlg, const std::string& searchCriteria, bool bUid, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  queryThread_impl(threadAlg, searchCriteria, bUid, json);
+}
+void HybridImap::queryThread_impl(const std::string& threadAlg, const std::string& searchCriteria, bool bUid, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  rt::checkNoNul(threadAlg, "threadAlg");
+  rt::checkNoNul(searchCriteria, "searchCriteria");
+  if (!this->ck().QueryThread(threadAlg.c_str(), searchCriteria.c_str(), bUid, rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("queryThread");
+}
+std::shared_ptr<Promise<void>> HybridImap::queryThreadAsync(const std::string& threadAlg, const std::string& searchCriteria, bool bUid, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(json);
+  return rt::runAsync<void>("Imap.queryThreadAsync", std::move(_parts), [_self, threadAlg, searchCriteria, bUid, json]() {
+    _self->queryThread_impl(threadAlg, searchCriteria, bUid, json);
+  });
+}
+
+void HybridImap::addPfxSourceBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& password) {
+  this->beginCall();
+  addPfxSourceBd_impl(bd, password);
+}
+void HybridImap::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 HybridImap::rawCommandBd(const std::shared_ptr<HybridBinDataSpec>& bdCmd, const std::shared_ptr<HybridBinDataSpec>& bdResp) {
+  this->beginCall();
+  rawCommandBd_impl(bdCmd, bdResp);
+}
+void HybridImap::rawCommandBd_impl(const std::shared_ptr<HybridBinDataSpec>& bdCmd, const std::shared_ptr<HybridBinDataSpec>& bdResp) {
+  if (!this->ck().RawCommandBd(rt::implOf<HybridBinData>(bdCmd, "bdCmd").ck(), rt::implOf<HybridBinData>(bdResp, "bdResp").ck())) throw this->fail("rawCommandBd");
+}
+std::shared_ptr<Promise<void>> HybridImap::rawCommandBdAsync(const std::shared_ptr<HybridBinDataSpec>& bdCmd, const std::shared_ptr<HybridBinDataSpec>& bdResp) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridImap>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bdCmd);
+  _parts.push_back(bdResp);
+  return rt::runAsync<void>("Imap.rawCommandBdAsync", std::move(_parts), [_self, bdCmd, bdResp]() {
+    _self->rawCommandBd_impl(bdCmd, bdResp);
+  });
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridImap::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridImap::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridImap::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridImap::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridImap::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat