@chilkat/react-native 11.6.1

package/cpp/HybridMht.cpp

@@ -0,0 +1,700 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridMht.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridMht::HybridMht()
+    : HybridObject(HybridMhtSpec::TAG), ChilkatObject<CkMht>("Mht", CkMht::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridMht::HybridMht(CkMht* owned)
+    : HybridObject(HybridMhtSpec::TAG), ChilkatObject<CkMht>("Mht", owned) {
+  init();
+}
+
+void HybridMht::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridMht::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridMht::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMht::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMht::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMht::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMht::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridMht::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridMht::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridMht::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridMht::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridMht::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridMht::getBaseUrl() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_BaseUrl(_s);
+  return rt::stdString(_s);
+}
+void HybridMht::setBaseUrl(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "baseUrl");
+  this->ck().put_BaseUrl(value.c_str());
+}
+double HybridMht::getConnectTimeout() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectTimeout());
+}
+void HybridMht::setConnectTimeout(double value) {
+  this->beginCall();
+  this->ck().put_ConnectTimeout(rt::toInt(value, "connectTimeout"));
+}
+std::string HybridMht::getDebugHtmlAfter() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugHtmlAfter(_s);
+  return rt::stdString(_s);
+}
+void HybridMht::setDebugHtmlAfter(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugHtmlAfter");
+  this->ck().put_DebugHtmlAfter(value.c_str());
+}
+std::string HybridMht::getDebugHtmlBefore() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugHtmlBefore(_s);
+  return rt::stdString(_s);
+}
+void HybridMht::setDebugHtmlBefore(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugHtmlBefore");
+  this->ck().put_DebugHtmlBefore(value.c_str());
+}
+bool HybridMht::getEmbedImages() {
+  this->beginCall();
+  return this->ck().get_EmbedImages();
+}
+void HybridMht::setEmbedImages(bool value) {
+  this->beginCall();
+  this->ck().put_EmbedImages(value);
+}
+bool HybridMht::getEmbedLocalOnly() {
+  this->beginCall();
+  return this->ck().get_EmbedLocalOnly();
+}
+void HybridMht::setEmbedLocalOnly(bool value) {
+  this->beginCall();
+  this->ck().put_EmbedLocalOnly(value);
+}
+bool HybridMht::getFetchFromCache() {
+  this->beginCall();
+  return this->ck().get_FetchFromCache();
+}
+void HybridMht::setFetchFromCache(bool value) {
+  this->beginCall();
+  this->ck().put_FetchFromCache(value);
+}
+double HybridMht::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridMht::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+bool HybridMht::getIgnoreMustRevalidate() {
+  this->beginCall();
+  return this->ck().get_IgnoreMustRevalidate();
+}
+void HybridMht::setIgnoreMustRevalidate(bool value) {
+  this->beginCall();
+  this->ck().put_IgnoreMustRevalidate(value);
+}
+bool HybridMht::getIgnoreNoCache() {
+  this->beginCall();
+  return this->ck().get_IgnoreNoCache();
+}
+void HybridMht::setIgnoreNoCache(bool value) {
+  this->beginCall();
+  this->ck().put_IgnoreNoCache(value);
+}
+bool HybridMht::getNoScripts() {
+  this->beginCall();
+  return this->ck().get_NoScripts();
+}
+void HybridMht::setNoScripts(bool value) {
+  this->beginCall();
+  this->ck().put_NoScripts(value);
+}
+bool HybridMht::getNtlmAuth() {
+  this->beginCall();
+  return this->ck().get_NtlmAuth();
+}
+void HybridMht::setNtlmAuth(bool value) {
+  this->beginCall();
+  this->ck().put_NtlmAuth(value);
+}
+double HybridMht::getNumCacheLevels() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumCacheLevels());
+}
+void HybridMht::setNumCacheLevels(double value) {
+  this->beginCall();
+  this->ck().put_NumCacheLevels(rt::toInt(value, "numCacheLevels"));
+}
+double HybridMht::getNumCacheRoots() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumCacheRoots());
+}
+bool HybridMht::getPreferIpv6() {
+  this->beginCall();
+  return this->ck().get_PreferIpv6();
+}
+void HybridMht::setPreferIpv6(bool value) {
+  this->beginCall();
+  this->ck().put_PreferIpv6(value);
+}
+bool HybridMht::getPreferMHTScripts() {
+  this->beginCall();
+  return this->ck().get_PreferMHTScripts();
+}
+void HybridMht::setPreferMHTScripts(bool value) {
+  this->beginCall();
+  this->ck().put_PreferMHTScripts(value);
+}
+std::string HybridMht::getProxy() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Proxy(_s);
+  return rt::stdString(_s);
+}
+void HybridMht::setProxy(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxy");
+  this->ck().put_Proxy(value.c_str());
+}
+std::string HybridMht::getProxyLogin() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyLogin(_s);
+  return rt::stdString(_s);
+}
+void HybridMht::setProxyLogin(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyLogin");
+  this->ck().put_ProxyLogin(value.c_str());
+}
+std::string HybridMht::getProxyPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridMht::setProxyPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyPassword");
+  this->ck().put_ProxyPassword(value.c_str());
+}
+double HybridMht::getReadTimeout() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ReadTimeout());
+}
+void HybridMht::setReadTimeout(double value) {
+  this->beginCall();
+  this->ck().put_ReadTimeout(rt::toInt(value, "readTimeout"));
+}
+bool HybridMht::getRequireSslCertVerify() {
+  this->beginCall();
+  return this->ck().get_RequireSslCertVerify();
+}
+void HybridMht::setRequireSslCertVerify(bool value) {
+  this->beginCall();
+  this->ck().put_RequireSslCertVerify(value);
+}
+std::string HybridMht::getSocksHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridMht::setSocksHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksHostname");
+  this->ck().put_SocksHostname(value.c_str());
+}
+std::string HybridMht::getSocksPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridMht::setSocksPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksPassword");
+  this->ck().put_SocksPassword(value.c_str());
+}
+double HybridMht::getSocksPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksPort());
+}
+void HybridMht::setSocksPort(double value) {
+  this->beginCall();
+  this->ck().put_SocksPort(rt::toInt(value, "socksPort"));
+}
+std::string HybridMht::getSocksUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridMht::setSocksUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksUsername");
+  this->ck().put_SocksUsername(value.c_str());
+}
+double HybridMht::getSocksVersion() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksVersion());
+}
+void HybridMht::setSocksVersion(double value) {
+  this->beginCall();
+  this->ck().put_SocksVersion(rt::toInt(value, "socksVersion"));
+}
+bool HybridMht::getUnpackDirect() {
+  this->beginCall();
+  return this->ck().get_UnpackDirect();
+}
+void HybridMht::setUnpackDirect(bool value) {
+  this->beginCall();
+  this->ck().put_UnpackDirect(value);
+}
+bool HybridMht::getUnpackUseRelPaths() {
+  this->beginCall();
+  return this->ck().get_UnpackUseRelPaths();
+}
+void HybridMht::setUnpackUseRelPaths(bool value) {
+  this->beginCall();
+  this->ck().put_UnpackUseRelPaths(value);
+}
+bool HybridMht::getUpdateCache() {
+  this->beginCall();
+  return this->ck().get_UpdateCache();
+}
+void HybridMht::setUpdateCache(bool value) {
+  this->beginCall();
+  this->ck().put_UpdateCache(value);
+}
+bool HybridMht::getUseCids() {
+  this->beginCall();
+  return this->ck().get_UseCids();
+}
+void HybridMht::setUseCids(bool value) {
+  this->beginCall();
+  this->ck().put_UseCids(value);
+}
+bool HybridMht::getUseFilename() {
+  this->beginCall();
+  return this->ck().get_UseFilename();
+}
+void HybridMht::setUseFilename(bool value) {
+  this->beginCall();
+  this->ck().put_UseFilename(value);
+}
+bool HybridMht::getUseIEProxy() {
+  this->beginCall();
+  return this->ck().get_UseIEProxy();
+}
+void HybridMht::setUseIEProxy(bool value) {
+  this->beginCall();
+  this->ck().put_UseIEProxy(value);
+}
+bool HybridMht::getUseInline() {
+  this->beginCall();
+  return this->ck().get_UseInline();
+}
+void HybridMht::setUseInline(bool value) {
+  this->beginCall();
+  this->ck().put_UseInline(value);
+}
+std::string HybridMht::getWebSiteLogin() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_WebSiteLogin(_s);
+  return rt::stdString(_s);
+}
+void HybridMht::setWebSiteLogin(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "webSiteLogin");
+  this->ck().put_WebSiteLogin(value.c_str());
+}
+std::string HybridMht::getWebSiteLoginDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_WebSiteLoginDomain(_s);
+  return rt::stdString(_s);
+}
+void HybridMht::setWebSiteLoginDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "webSiteLoginDomain");
+  this->ck().put_WebSiteLoginDomain(value.c_str());
+}
+std::string HybridMht::getWebSitePassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_WebSitePassword(_s);
+  return rt::stdString(_s);
+}
+void HybridMht::setWebSitePassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "webSitePassword");
+  this->ck().put_WebSitePassword(value.c_str());
+}
+bool HybridMht::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridMht::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+
+// ---- Methods ----
+
+void HybridMht::addCacheRoot(const std::string& dir) {
+  this->beginCall();
+  addCacheRoot_impl(dir);
+}
+void HybridMht::addCacheRoot_impl(const std::string& dir) {
+  rt::checkNoNul(dir, "dir");
+  this->ck().AddCacheRoot(dir.c_str());
+}
+
+void HybridMht::addCustomHeader(const std::string& name, const std::string& value) {
+  this->beginCall();
+  addCustomHeader_impl(name, value);
+}
+void HybridMht::addCustomHeader_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  this->ck().AddCustomHeader(name.c_str(), value.c_str());
+}
+
+void HybridMht::addExternalStyleSheet(const std::string& url) {
+  this->beginCall();
+  addExternalStyleSheet_impl(url);
+}
+void HybridMht::addExternalStyleSheet_impl(const std::string& url) {
+  rt::checkNoNul(url, "url");
+  this->ck().AddExternalStyleSheet(url.c_str());
+}
+
+void HybridMht::clearCustomHeaders() {
+  this->beginCall();
+  clearCustomHeaders_impl();
+}
+void HybridMht::clearCustomHeaders_impl() {
+  this->ck().ClearCustomHeaders();
+}
+
+void HybridMht::excludeImagesMatching(const std::string& pattern) {
+  this->beginCall();
+  excludeImagesMatching_impl(pattern);
+}
+void HybridMht::excludeImagesMatching_impl(const std::string& pattern) {
+  rt::checkNoNul(pattern, "pattern");
+  this->ck().ExcludeImagesMatching(pattern.c_str());
+}
+
+void HybridMht::getAndSaveEML(const std::string& urlOrHtmlFilepath, const std::string& emlPath) {
+  this->beginCall();
+  getAndSaveEML_impl(urlOrHtmlFilepath, emlPath);
+}
+void HybridMht::getAndSaveEML_impl(const std::string& urlOrHtmlFilepath, const std::string& emlPath) {
+  rt::checkNoNul(urlOrHtmlFilepath, "urlOrHtmlFilepath");
+  rt::checkNoNul(emlPath, "emlPath");
+  if (!this->ck().GetAndSaveEML(urlOrHtmlFilepath.c_str(), emlPath.c_str())) throw this->fail("getAndSaveEML");
+}
+std::shared_ptr<Promise<void>> HybridMht::getAndSaveEMLAsync(const std::string& urlOrHtmlFilepath, const std::string& emlPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMht>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Mht.getAndSaveEMLAsync", std::move(_parts), [_self, urlOrHtmlFilepath, emlPath]() {
+    _self->getAndSaveEML_impl(urlOrHtmlFilepath, emlPath);
+  });
+}
+
+void HybridMht::getAndSaveMHT(const std::string& urlOrHtmlFilepath, const std::string& mhtPath) {
+  this->beginCall();
+  getAndSaveMHT_impl(urlOrHtmlFilepath, mhtPath);
+}
+void HybridMht::getAndSaveMHT_impl(const std::string& urlOrHtmlFilepath, const std::string& mhtPath) {
+  rt::checkNoNul(urlOrHtmlFilepath, "urlOrHtmlFilepath");
+  rt::checkNoNul(mhtPath, "mhtPath");
+  if (!this->ck().GetAndSaveMHT(urlOrHtmlFilepath.c_str(), mhtPath.c_str())) throw this->fail("getAndSaveMHT");
+}
+std::shared_ptr<Promise<void>> HybridMht::getAndSaveMHTAsync(const std::string& urlOrHtmlFilepath, const std::string& mhtPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMht>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Mht.getAndSaveMHTAsync", std::move(_parts), [_self, urlOrHtmlFilepath, mhtPath]() {
+    _self->getAndSaveMHT_impl(urlOrHtmlFilepath, mhtPath);
+  });
+}
+
+void HybridMht::getAndZipEML(const std::string& urlOrHtmlFilepath, const std::string& zipEntryFilename, const std::string& zipFilename) {
+  this->beginCall();
+  getAndZipEML_impl(urlOrHtmlFilepath, zipEntryFilename, zipFilename);
+}
+void HybridMht::getAndZipEML_impl(const std::string& urlOrHtmlFilepath, const std::string& zipEntryFilename, const std::string& zipFilename) {
+  rt::checkNoNul(urlOrHtmlFilepath, "urlOrHtmlFilepath");
+  rt::checkNoNul(zipEntryFilename, "zipEntryFilename");
+  rt::checkNoNul(zipFilename, "zipFilename");
+  if (!this->ck().GetAndZipEML(urlOrHtmlFilepath.c_str(), zipEntryFilename.c_str(), zipFilename.c_str())) throw this->fail("getAndZipEML");
+}
+std::shared_ptr<Promise<void>> HybridMht::getAndZipEMLAsync(const std::string& urlOrHtmlFilepath, const std::string& zipEntryFilename, const std::string& zipFilename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMht>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Mht.getAndZipEMLAsync", std::move(_parts), [_self, urlOrHtmlFilepath, zipEntryFilename, zipFilename]() {
+    _self->getAndZipEML_impl(urlOrHtmlFilepath, zipEntryFilename, zipFilename);
+  });
+}
+
+void HybridMht::getAndZipMHT(const std::string& urlOrHtmlFilepath, const std::string& zipEntryFilename, const std::string& zipFilename) {
+  this->beginCall();
+  getAndZipMHT_impl(urlOrHtmlFilepath, zipEntryFilename, zipFilename);
+}
+void HybridMht::getAndZipMHT_impl(const std::string& urlOrHtmlFilepath, const std::string& zipEntryFilename, const std::string& zipFilename) {
+  rt::checkNoNul(urlOrHtmlFilepath, "urlOrHtmlFilepath");
+  rt::checkNoNul(zipEntryFilename, "zipEntryFilename");
+  rt::checkNoNul(zipFilename, "zipFilename");
+  if (!this->ck().GetAndZipMHT(urlOrHtmlFilepath.c_str(), zipEntryFilename.c_str(), zipFilename.c_str())) throw this->fail("getAndZipMHT");
+}
+std::shared_ptr<Promise<void>> HybridMht::getAndZipMHTAsync(const std::string& urlOrHtmlFilepath, const std::string& zipEntryFilename, const std::string& zipFilename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMht>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Mht.getAndZipMHTAsync", std::move(_parts), [_self, urlOrHtmlFilepath, zipEntryFilename, zipFilename]() {
+    _self->getAndZipMHT_impl(urlOrHtmlFilepath, zipEntryFilename, zipFilename);
+  });
+}
+
+std::string HybridMht::getCacheRoot(double index) {
+  this->beginCall();
+  return getCacheRoot_impl(index);
+}
+std::string HybridMht::getCacheRoot_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetCacheRoot(rt::toInt(index, "index"), _out)) throw this->fail("getCacheRoot");
+  return rt::stdString(_out);
+}
+
+std::string HybridMht::getEML(const std::string& urlOrHtmlFilepath) {
+  this->beginCall();
+  return getEML_impl(urlOrHtmlFilepath);
+}
+std::string HybridMht::getEML_impl(const std::string& urlOrHtmlFilepath) {
+  rt::checkNoNul(urlOrHtmlFilepath, "urlOrHtmlFilepath");
+  CkString _out;
+  if (!this->ck().GetEML(urlOrHtmlFilepath.c_str(), _out)) throw this->fail("getEML");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridMht::getEMLAsync(const std::string& urlOrHtmlFilepath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMht>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Mht.getEMLAsync", std::move(_parts), [_self, urlOrHtmlFilepath]() {
+    return _self->getEML_impl(urlOrHtmlFilepath);
+  });
+}
+
+std::string HybridMht::getMHT(const std::string& urlOrHtmlFilepath) {
+  this->beginCall();
+  return getMHT_impl(urlOrHtmlFilepath);
+}
+std::string HybridMht::getMHT_impl(const std::string& urlOrHtmlFilepath) {
+  rt::checkNoNul(urlOrHtmlFilepath, "urlOrHtmlFilepath");
+  CkString _out;
+  if (!this->ck().GetMHT(urlOrHtmlFilepath.c_str(), _out)) throw this->fail("getMHT");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridMht::getMHTAsync(const std::string& urlOrHtmlFilepath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMht>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Mht.getMHTAsync", std::move(_parts), [_self, urlOrHtmlFilepath]() {
+    return _self->getMHT_impl(urlOrHtmlFilepath);
+  });
+}
+
+std::string HybridMht::htmlToEML(const std::string& htmlText) {
+  this->beginCall();
+  return htmlToEML_impl(htmlText);
+}
+std::string HybridMht::htmlToEML_impl(const std::string& htmlText) {
+  rt::checkNoNul(htmlText, "htmlText");
+  CkString _out;
+  if (!this->ck().HtmlToEML(htmlText.c_str(), _out)) throw this->fail("htmlToEML");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridMht::htmlToEMLAsync(const std::string& htmlText) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMht>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Mht.htmlToEMLAsync", std::move(_parts), [_self, htmlText]() {
+    return _self->htmlToEML_impl(htmlText);
+  });
+}
+
+void HybridMht::htmlToEMLFile(const std::string& html, const std::string& emlFilename) {
+  this->beginCall();
+  htmlToEMLFile_impl(html, emlFilename);
+}
+void HybridMht::htmlToEMLFile_impl(const std::string& html, const std::string& emlFilename) {
+  rt::checkNoNul(html, "html");
+  rt::checkNoNul(emlFilename, "emlFilename");
+  if (!this->ck().HtmlToEMLFile(html.c_str(), emlFilename.c_str())) throw this->fail("htmlToEMLFile");
+}
+std::shared_ptr<Promise<void>> HybridMht::htmlToEMLFileAsync(const std::string& html, const std::string& emlFilename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMht>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Mht.htmlToEMLFileAsync", std::move(_parts), [_self, html, emlFilename]() {
+    _self->htmlToEMLFile_impl(html, emlFilename);
+  });
+}
+
+std::string HybridMht::htmlToMHT(const std::string& htmlText) {
+  this->beginCall();
+  return htmlToMHT_impl(htmlText);
+}
+std::string HybridMht::htmlToMHT_impl(const std::string& htmlText) {
+  rt::checkNoNul(htmlText, "htmlText");
+  CkString _out;
+  if (!this->ck().HtmlToMHT(htmlText.c_str(), _out)) throw this->fail("htmlToMHT");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridMht::htmlToMHTAsync(const std::string& htmlText) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMht>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Mht.htmlToMHTAsync", std::move(_parts), [_self, htmlText]() {
+    return _self->htmlToMHT_impl(htmlText);
+  });
+}
+
+void HybridMht::htmlToMHTFile(const std::string& html, const std::string& mhtFilename) {
+  this->beginCall();
+  htmlToMHTFile_impl(html, mhtFilename);
+}
+void HybridMht::htmlToMHTFile_impl(const std::string& html, const std::string& mhtFilename) {
+  rt::checkNoNul(html, "html");
+  rt::checkNoNul(mhtFilename, "mhtFilename");
+  if (!this->ck().HtmlToMHTFile(html.c_str(), mhtFilename.c_str())) throw this->fail("htmlToMHTFile");
+}
+std::shared_ptr<Promise<void>> HybridMht::htmlToMHTFileAsync(const std::string& html, const std::string& mhtFilename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMht>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Mht.htmlToMHTFileAsync", std::move(_parts), [_self, html, mhtFilename]() {
+    _self->htmlToMHTFile_impl(html, mhtFilename);
+  });
+}
+
+void HybridMht::removeCustomHeader(const std::string& name) {
+  this->beginCall();
+  removeCustomHeader_impl(name);
+}
+void HybridMht::removeCustomHeader_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  this->ck().RemoveCustomHeader(name.c_str());
+}
+
+void HybridMht::restoreDefaults() {
+  this->beginCall();
+  restoreDefaults_impl();
+}
+void HybridMht::restoreDefaults_impl() {
+  this->ck().RestoreDefaults();
+}
+
+void HybridMht::unpackMHT(const std::string& mhtFilename, const std::string& unpackDir, const std::string& htmlFilename, const std::string& partsSubDir) {
+  this->beginCall();
+  unpackMHT_impl(mhtFilename, unpackDir, htmlFilename, partsSubDir);
+}
+void HybridMht::unpackMHT_impl(const std::string& mhtFilename, const std::string& unpackDir, const std::string& htmlFilename, const std::string& partsSubDir) {
+  rt::checkNoNul(mhtFilename, "mhtFilename");
+  rt::checkNoNul(unpackDir, "unpackDir");
+  rt::checkNoNul(htmlFilename, "htmlFilename");
+  rt::checkNoNul(partsSubDir, "partsSubDir");
+  if (!this->ck().UnpackMHT(mhtFilename.c_str(), unpackDir.c_str(), htmlFilename.c_str(), partsSubDir.c_str())) throw this->fail("unpackMHT");
+}
+
+void HybridMht::unpackMHTString(const std::string& mhtString, const std::string& unpackDir, const std::string& htmlFilename, const std::string& partsSubDir) {
+  this->beginCall();
+  unpackMHTString_impl(mhtString, unpackDir, htmlFilename, partsSubDir);
+}
+void HybridMht::unpackMHTString_impl(const std::string& mhtString, const std::string& unpackDir, const std::string& htmlFilename, const std::string& partsSubDir) {
+  rt::checkNoNul(mhtString, "mhtString");
+  rt::checkNoNul(unpackDir, "unpackDir");
+  rt::checkNoNul(htmlFilename, "htmlFilename");
+  rt::checkNoNul(partsSubDir, "partsSubDir");
+  if (!this->ck().UnpackMHTString(mhtString.c_str(), unpackDir.c_str(), htmlFilename.c_str(), partsSubDir.c_str())) throw this->fail("unpackMHTString");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridMht::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridMht::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridMht::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridMht::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridMht::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat