@chilkat/react-native 11.6.1

package/cpp/HybridFtp2.cpp

@@ -0,0 +1,2308 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridFtp2.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCert.hpp"
+#include "HybridCkDateTime.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridSecureString.hpp"
+#include "HybridStream.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridStringTable.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+#include <CkFtp2Progress.h>
+
+namespace margelo::nitro::chilkat {
+
+HybridFtp2::HybridFtp2()
+    : HybridObject(HybridFtp2Spec::TAG), ChilkatObject<CkFtp2>("Ftp2", CkFtp2::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridFtp2::HybridFtp2(CkFtp2* owned)
+    : HybridObject(HybridFtp2Spec::TAG), ChilkatObject<CkFtp2>("Ftp2", owned) {
+  init();
+}
+
+void HybridFtp2::init() {
+  this->installProgress<ProgressAdapter<CkFtp2Progress>>();
+}
+
+void HybridFtp2::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridFtp2::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridFtp2::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridFtp2::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridFtp2::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridFtp2::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridFtp2::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridFtp2::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridFtp2::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridFtp2::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridFtp2::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridFtp2::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+std::string HybridFtp2::getAccount() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Account(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setAccount(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "account");
+  this->ck().put_Account(value.c_str());
+}
+double HybridFtp2::getActivePortRangeEnd() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ActivePortRangeEnd());
+}
+void HybridFtp2::setActivePortRangeEnd(double value) {
+  this->beginCall();
+  this->ck().put_ActivePortRangeEnd(rt::toInt(value, "activePortRangeEnd"));
+}
+double HybridFtp2::getActivePortRangeStart() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ActivePortRangeStart());
+}
+void HybridFtp2::setActivePortRangeStart(double value) {
+  this->beginCall();
+  this->ck().put_ActivePortRangeStart(rt::toInt(value, "activePortRangeStart"));
+}
+double HybridFtp2::getAllocateSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_AllocateSize());
+}
+void HybridFtp2::setAllocateSize(double value) {
+  this->beginCall();
+  this->ck().put_AllocateSize(rt::toULong(value, "allocateSize"));
+}
+bool HybridFtp2::getAllowMlsd() {
+  this->beginCall();
+  return this->ck().get_AllowMlsd();
+}
+void HybridFtp2::setAllowMlsd(bool value) {
+  this->beginCall();
+  this->ck().put_AllowMlsd(value);
+}
+double HybridFtp2::getCurBytesReceived() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_CurBytesReceived());
+}
+double HybridFtp2::getCurBytesReceived64() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_CurBytesReceived64());
+}
+std::string HybridFtp2::getCurBytesReceivedStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CurBytesReceivedStr(_s);
+  return rt::stdString(_s);
+}
+double HybridFtp2::getCurBytesSent() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_CurBytesSent());
+}
+double HybridFtp2::getCurBytesSent64() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_CurBytesSent64());
+}
+std::string HybridFtp2::getCurBytesSentStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CurBytesSentStr(_s);
+  return rt::stdString(_s);
+}
+bool HybridFtp2::getAuthSsl() {
+  this->beginCall();
+  return this->ck().get_AuthSsl();
+}
+void HybridFtp2::setAuthSsl(bool value) {
+  this->beginCall();
+  this->ck().put_AuthSsl(value);
+}
+bool HybridFtp2::getAuthTls() {
+  this->beginCall();
+  return this->ck().get_AuthTls();
+}
+void HybridFtp2::setAuthTls(bool value) {
+  this->beginCall();
+  this->ck().put_AuthTls(value);
+}
+bool HybridFtp2::getAutoFeat() {
+  this->beginCall();
+  return this->ck().get_AutoFeat();
+}
+void HybridFtp2::setAutoFeat(bool value) {
+  this->beginCall();
+  this->ck().put_AutoFeat(value);
+}
+bool HybridFtp2::getAutoFix() {
+  this->beginCall();
+  return this->ck().get_AutoFix();
+}
+void HybridFtp2::setAutoFix(bool value) {
+  this->beginCall();
+  this->ck().put_AutoFix(value);
+}
+bool HybridFtp2::getAutoGetSizeForProgress() {
+  this->beginCall();
+  return this->ck().get_AutoGetSizeForProgress();
+}
+void HybridFtp2::setAutoGetSizeForProgress(bool value) {
+  this->beginCall();
+  this->ck().put_AutoGetSizeForProgress(value);
+}
+bool HybridFtp2::getAutoOptsUtf8() {
+  this->beginCall();
+  return this->ck().get_AutoOptsUtf8();
+}
+void HybridFtp2::setAutoOptsUtf8(bool value) {
+  this->beginCall();
+  this->ck().put_AutoOptsUtf8(value);
+}
+bool HybridFtp2::getAutoSetUseEpsv() {
+  this->beginCall();
+  return this->ck().get_AutoSetUseEpsv();
+}
+void HybridFtp2::setAutoSetUseEpsv(bool value) {
+  this->beginCall();
+  this->ck().put_AutoSetUseEpsv(value);
+}
+bool HybridFtp2::getAutoSyst() {
+  this->beginCall();
+  return this->ck().get_AutoSyst();
+}
+void HybridFtp2::setAutoSyst(bool value) {
+  this->beginCall();
+  this->ck().put_AutoSyst(value);
+}
+bool HybridFtp2::getAutoXcrc() {
+  this->beginCall();
+  return this->ck().get_AutoXcrc();
+}
+void HybridFtp2::setAutoXcrc(bool value) {
+  this->beginCall();
+  this->ck().put_AutoXcrc(value);
+}
+double HybridFtp2::getBandwidthThrottleDown() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_BandwidthThrottleDown());
+}
+void HybridFtp2::setBandwidthThrottleDown(double value) {
+  this->beginCall();
+  this->ck().put_BandwidthThrottleDown(rt::toInt(value, "bandwidthThrottleDown"));
+}
+double HybridFtp2::getBandwidthThrottleUp() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_BandwidthThrottleUp());
+}
+void HybridFtp2::setBandwidthThrottleUp(double value) {
+  this->beginCall();
+  this->ck().put_BandwidthThrottleUp(rt::toInt(value, "bandwidthThrottleUp"));
+}
+std::string HybridFtp2::getClientIpAddress() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ClientIpAddress(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setClientIpAddress(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "clientIpAddress");
+  this->ck().put_ClientIpAddress(value.c_str());
+}
+std::string HybridFtp2::getCommandCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CommandCharset(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setCommandCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "commandCharset");
+  this->ck().put_CommandCharset(value.c_str());
+}
+double HybridFtp2::getConnectFailReason() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectFailReason());
+}
+double HybridFtp2::getConnectTimeout() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectTimeout());
+}
+void HybridFtp2::setConnectTimeout(double value) {
+  this->beginCall();
+  this->ck().put_ConnectTimeout(rt::toInt(value, "connectTimeout"));
+}
+bool HybridFtp2::getConnectVerified() {
+  this->beginCall();
+  return this->ck().get_ConnectVerified();
+}
+double HybridFtp2::getCrlfMode() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_CrlfMode());
+}
+void HybridFtp2::setCrlfMode(double value) {
+  this->beginCall();
+  this->ck().put_CrlfMode(rt::toInt(value, "crlfMode"));
+}
+std::string HybridFtp2::getDataProtection() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DataProtection(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setDataProtection(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "dataProtection");
+  this->ck().put_DataProtection(value.c_str());
+}
+std::string HybridFtp2::getDirListingCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DirListingCharset(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setDirListingCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "dirListingCharset");
+  this->ck().put_DirListingCharset(value.c_str());
+}
+double HybridFtp2::getDownloadTransferRate() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_DownloadTransferRate());
+}
+std::string HybridFtp2::getForcePortIpAddress() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ForcePortIpAddress(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setForcePortIpAddress(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "forcePortIpAddress");
+  this->ck().put_ForcePortIpAddress(value.c_str());
+}
+std::string HybridFtp2::getGreeting() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Greeting(_s);
+  return rt::stdString(_s);
+}
+bool HybridFtp2::getHasModeZ() {
+  this->beginCall();
+  return this->ck().get_HasModeZ();
+}
+double HybridFtp2::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridFtp2::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+std::string HybridFtp2::getHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Hostname(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "hostname");
+  this->ck().put_Hostname(value.c_str());
+}
+std::string HybridFtp2::getHttpProxyAuthMethod() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyAuthMethod(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setHttpProxyAuthMethod(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyAuthMethod");
+  this->ck().put_HttpProxyAuthMethod(value.c_str());
+}
+std::string HybridFtp2::getHttpProxyDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyDomain(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setHttpProxyDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyDomain");
+  this->ck().put_HttpProxyDomain(value.c_str());
+}
+std::string HybridFtp2::getHttpProxyHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setHttpProxyHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyHostname");
+  this->ck().put_HttpProxyHostname(value.c_str());
+}
+std::string HybridFtp2::getHttpProxyPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setHttpProxyPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyPassword");
+  this->ck().put_HttpProxyPassword(value.c_str());
+}
+double HybridFtp2::getHttpProxyPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HttpProxyPort());
+}
+void HybridFtp2::setHttpProxyPort(double value) {
+  this->beginCall();
+  this->ck().put_HttpProxyPort(rt::toInt(value, "httpProxyPort"));
+}
+std::string HybridFtp2::getHttpProxyUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setHttpProxyUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyUsername");
+  this->ck().put_HttpProxyUsername(value.c_str());
+}
+double HybridFtp2::getIdleTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_IdleTimeoutMs());
+}
+void HybridFtp2::setIdleTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_IdleTimeoutMs(rt::toInt(value, "idleTimeoutMs"));
+}
+bool HybridFtp2::getIsConnected() {
+  this->beginCall();
+  return this->ck().get_IsConnected();
+}
+bool HybridFtp2::getKeepSessionLog() {
+  this->beginCall();
+  return this->ck().get_KeepSessionLog();
+}
+void HybridFtp2::setKeepSessionLog(bool value) {
+  this->beginCall();
+  this->ck().put_KeepSessionLog(value);
+}
+std::string HybridFtp2::getLastReply() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastReply(_s);
+  return rt::stdString(_s);
+}
+std::string HybridFtp2::getListPattern() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ListPattern(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setListPattern(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "listPattern");
+  this->ck().put_ListPattern(value.c_str());
+}
+bool HybridFtp2::getLoginVerified() {
+  this->beginCall();
+  return this->ck().get_LoginVerified();
+}
+bool HybridFtp2::getPartialTransfer() {
+  this->beginCall();
+  return this->ck().get_PartialTransfer();
+}
+bool HybridFtp2::getPassive() {
+  this->beginCall();
+  return this->ck().get_Passive();
+}
+void HybridFtp2::setPassive(bool value) {
+  this->beginCall();
+  this->ck().put_Passive(value);
+}
+bool HybridFtp2::getPassiveUseHostAddr() {
+  this->beginCall();
+  return this->ck().get_PassiveUseHostAddr();
+}
+void HybridFtp2::setPassiveUseHostAddr(bool value) {
+  this->beginCall();
+  this->ck().put_PassiveUseHostAddr(value);
+}
+std::string HybridFtp2::getPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Password(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "password");
+  this->ck().put_Password(value.c_str());
+}
+double HybridFtp2::getPercentDoneScale() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_PercentDoneScale());
+}
+void HybridFtp2::setPercentDoneScale(double value) {
+  this->beginCall();
+  this->ck().put_PercentDoneScale(rt::toInt(value, "percentDoneScale"));
+}
+double HybridFtp2::getPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Port());
+}
+void HybridFtp2::setPort(double value) {
+  this->beginCall();
+  this->ck().put_Port(rt::toInt(value, "port"));
+}
+bool HybridFtp2::getPreferIpv6() {
+  this->beginCall();
+  return this->ck().get_PreferIpv6();
+}
+void HybridFtp2::setPreferIpv6(bool value) {
+  this->beginCall();
+  this->ck().put_PreferIpv6(value);
+}
+bool HybridFtp2::getPreferNlst() {
+  this->beginCall();
+  return this->ck().get_PreferNlst();
+}
+void HybridFtp2::setPreferNlst(bool value) {
+  this->beginCall();
+  this->ck().put_PreferNlst(value);
+}
+double HybridFtp2::getProgressMonSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ProgressMonSize());
+}
+void HybridFtp2::setProgressMonSize(double value) {
+  this->beginCall();
+  this->ck().put_ProgressMonSize(rt::toInt(value, "progressMonSize"));
+}
+double HybridFtp2::getProgressMonSize64() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ProgressMonSize64());
+}
+void HybridFtp2::setProgressMonSize64(double value) {
+  this->beginCall();
+  this->ck().put_ProgressMonSize64(rt::toInt64(value, "progressMonSize64"));
+}
+std::string HybridFtp2::getProxyHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setProxyHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyHostname");
+  this->ck().put_ProxyHostname(value.c_str());
+}
+double HybridFtp2::getProxyMethod() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ProxyMethod());
+}
+void HybridFtp2::setProxyMethod(double value) {
+  this->beginCall();
+  this->ck().put_ProxyMethod(rt::toInt(value, "proxyMethod"));
+}
+std::string HybridFtp2::getProxyPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setProxyPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyPassword");
+  this->ck().put_ProxyPassword(value.c_str());
+}
+double HybridFtp2::getProxyPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ProxyPort());
+}
+void HybridFtp2::setProxyPort(double value) {
+  this->beginCall();
+  this->ck().put_ProxyPort(rt::toInt(value, "proxyPort"));
+}
+std::string HybridFtp2::getProxyUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setProxyUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyUsername");
+  this->ck().put_ProxyUsername(value.c_str());
+}
+double HybridFtp2::getReadTimeout() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ReadTimeout());
+}
+void HybridFtp2::setReadTimeout(double value) {
+  this->beginCall();
+  this->ck().put_ReadTimeout(rt::toInt(value, "readTimeout"));
+}
+bool HybridFtp2::getRequireSslCertVerify() {
+  this->beginCall();
+  return this->ck().get_RequireSslCertVerify();
+}
+void HybridFtp2::setRequireSslCertVerify(bool value) {
+  this->beginCall();
+  this->ck().put_RequireSslCertVerify(value);
+}
+bool HybridFtp2::getRestartNext() {
+  this->beginCall();
+  return this->ck().get_RestartNext();
+}
+void HybridFtp2::setRestartNext(bool value) {
+  this->beginCall();
+  this->ck().put_RestartNext(value);
+}
+std::string HybridFtp2::getSessionLog() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SessionLog(_s);
+  return rt::stdString(_s);
+}
+double HybridFtp2::getSoRcvBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoRcvBuf());
+}
+void HybridFtp2::setSoRcvBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoRcvBuf(rt::toInt(value, "soRcvBuf"));
+}
+double HybridFtp2::getSoSndBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoSndBuf());
+}
+void HybridFtp2::setSoSndBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoSndBuf(rt::toInt(value, "soSndBuf"));
+}
+std::string HybridFtp2::getSocksHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setSocksHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksHostname");
+  this->ck().put_SocksHostname(value.c_str());
+}
+std::string HybridFtp2::getSocksPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setSocksPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksPassword");
+  this->ck().put_SocksPassword(value.c_str());
+}
+double HybridFtp2::getSocksPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksPort());
+}
+void HybridFtp2::setSocksPort(double value) {
+  this->beginCall();
+  this->ck().put_SocksPort(rt::toInt(value, "socksPort"));
+}
+std::string HybridFtp2::getSocksUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setSocksUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksUsername");
+  this->ck().put_SocksUsername(value.c_str());
+}
+double HybridFtp2::getSocksVersion() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksVersion());
+}
+void HybridFtp2::setSocksVersion(double value) {
+  this->beginCall();
+  this->ck().put_SocksVersion(rt::toInt(value, "socksVersion"));
+}
+bool HybridFtp2::getSsl() {
+  this->beginCall();
+  return this->ck().get_Ssl();
+}
+void HybridFtp2::setSsl(bool value) {
+  this->beginCall();
+  this->ck().put_Ssl(value);
+}
+std::string HybridFtp2::getSslAllowedCiphers() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SslAllowedCiphers(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setSslAllowedCiphers(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sslAllowedCiphers");
+  this->ck().put_SslAllowedCiphers(value.c_str());
+}
+std::string HybridFtp2::getSslProtocol() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SslProtocol(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setSslProtocol(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sslProtocol");
+  this->ck().put_SslProtocol(value.c_str());
+}
+bool HybridFtp2::getSslServerCertVerified() {
+  this->beginCall();
+  return this->ck().get_SslServerCertVerified();
+}
+std::string HybridFtp2::getSyncMustMatch() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SyncMustMatch(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setSyncMustMatch(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "syncMustMatch");
+  this->ck().put_SyncMustMatch(value.c_str());
+}
+std::string HybridFtp2::getSyncMustNotMatch() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SyncMustNotMatch(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setSyncMustNotMatch(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "syncMustNotMatch");
+  this->ck().put_SyncMustNotMatch(value.c_str());
+}
+std::string HybridFtp2::getSyncPreview() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SyncPreview(_s);
+  return rt::stdString(_s);
+}
+std::string HybridFtp2::getTlsCipherSuite() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsCipherSuite(_s);
+  return rt::stdString(_s);
+}
+std::string HybridFtp2::getTlsPinSet() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsPinSet(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setTlsPinSet(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "tlsPinSet");
+  this->ck().put_TlsPinSet(value.c_str());
+}
+std::string HybridFtp2::getTlsVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsVersion(_s);
+  return rt::stdString(_s);
+}
+double HybridFtp2::getUploadTransferRate() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_UploadTransferRate());
+}
+bool HybridFtp2::getUseEpsv() {
+  this->beginCall();
+  return this->ck().get_UseEpsv();
+}
+void HybridFtp2::setUseEpsv(bool value) {
+  this->beginCall();
+  this->ck().put_UseEpsv(value);
+}
+std::string HybridFtp2::getUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Username(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "username");
+  this->ck().put_Username(value.c_str());
+}
+bool HybridFtp2::getLargeFileMeasures() {
+  this->beginCall();
+  return this->ck().get_LargeFileMeasures();
+}
+void HybridFtp2::setLargeFileMeasures(bool value) {
+  this->beginCall();
+  this->ck().put_LargeFileMeasures(value);
+}
+std::string HybridFtp2::getSyncMustMatchDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SyncMustMatchDir(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setSyncMustMatchDir(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "syncMustMatchDir");
+  this->ck().put_SyncMustMatchDir(value.c_str());
+}
+std::string HybridFtp2::getSyncMustNotMatchDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SyncMustNotMatchDir(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setSyncMustNotMatchDir(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "syncMustNotMatchDir");
+  this->ck().put_SyncMustNotMatchDir(value.c_str());
+}
+bool HybridFtp2::getSyncCreateAllLocalDirs() {
+  this->beginCall();
+  return this->ck().get_SyncCreateAllLocalDirs();
+}
+void HybridFtp2::setSyncCreateAllLocalDirs(bool value) {
+  this->beginCall();
+  this->ck().put_SyncCreateAllLocalDirs(value);
+}
+std::string HybridFtp2::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+std::string HybridFtp2::getListOption() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ListOption(_s);
+  return rt::stdString(_s);
+}
+void HybridFtp2::setListOption(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "listOption");
+  this->ck().put_ListOption(value.c_str());
+}
+bool HybridFtp2::getEnableSecrets() {
+  this->beginCall();
+  return this->ck().get_EnableSecrets();
+}
+void HybridFtp2::setEnableSecrets(bool value) {
+  this->beginCall();
+  this->ck().put_EnableSecrets(value);
+}
+
+// ---- Methods ----
+
+void HybridFtp2::appendFile(const std::string& localFilePath, const std::string& remoteFilePath) {
+  this->beginCall();
+  appendFile_impl(localFilePath, remoteFilePath);
+}
+void HybridFtp2::appendFile_impl(const std::string& localFilePath, const std::string& remoteFilePath) {
+  rt::checkNoNul(localFilePath, "localFilePath");
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  if (!this->ck().AppendFile(localFilePath.c_str(), remoteFilePath.c_str())) throw this->fail("appendFile");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::appendFileAsync(const std::string& localFilePath, const std::string& remoteFilePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.appendFileAsync", std::move(_parts), [_self, localFilePath, remoteFilePath]() {
+    _self->appendFile_impl(localFilePath, remoteFilePath);
+  });
+}
+
+void HybridFtp2::appendFileFromTextData(const std::string& remoteFilename, const std::string& textData, const std::string& charset) {
+  this->beginCall();
+  appendFileFromTextData_impl(remoteFilename, textData, charset);
+}
+void HybridFtp2::appendFileFromTextData_impl(const std::string& remoteFilename, const std::string& textData, const std::string& charset) {
+  rt::checkNoNul(remoteFilename, "remoteFilename");
+  rt::checkNoNul(textData, "textData");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().AppendFileFromTextData(remoteFilename.c_str(), textData.c_str(), charset.c_str())) throw this->fail("appendFileFromTextData");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::appendFileFromTextDataAsync(const std::string& remoteFilename, const std::string& textData, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.appendFileFromTextDataAsync", std::move(_parts), [_self, remoteFilename, textData, charset]() {
+    _self->appendFileFromTextData_impl(remoteFilename, textData, charset);
+  });
+}
+
+void HybridFtp2::changeRemoteDir(const std::string& remoteDirPath) {
+  this->beginCall();
+  changeRemoteDir_impl(remoteDirPath);
+}
+void HybridFtp2::changeRemoteDir_impl(const std::string& remoteDirPath) {
+  rt::checkNoNul(remoteDirPath, "remoteDirPath");
+  if (!this->ck().ChangeRemoteDir(remoteDirPath.c_str())) throw this->fail("changeRemoteDir");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::changeRemoteDirAsync(const std::string& remoteDirPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.changeRemoteDirAsync", std::move(_parts), [_self, remoteDirPath]() {
+    _self->changeRemoteDir_impl(remoteDirPath);
+  });
+}
+
+bool HybridFtp2::checkConnection() {
+  this->beginCall();
+  return checkConnection_impl();
+}
+bool HybridFtp2::checkConnection_impl() {
+  return this->ck().CheckConnection();
+}
+std::shared_ptr<Promise<bool>> HybridFtp2::checkConnectionAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<bool>("Ftp2.checkConnectionAsync", std::move(_parts), [_self]() {
+    return _self->checkConnection_impl();
+  });
+}
+
+void HybridFtp2::clearControlChannel() {
+  this->beginCall();
+  clearControlChannel_impl();
+}
+void HybridFtp2::clearControlChannel_impl() {
+  if (!this->ck().ClearControlChannel()) throw this->fail("clearControlChannel");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::clearControlChannelAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.clearControlChannelAsync", std::move(_parts), [_self]() {
+    _self->clearControlChannel_impl();
+  });
+}
+
+void HybridFtp2::clearDirCache() {
+  this->beginCall();
+  clearDirCache_impl();
+}
+void HybridFtp2::clearDirCache_impl() {
+  this->ck().ClearDirCache();
+}
+
+void HybridFtp2::clearSessionLog() {
+  this->beginCall();
+  clearSessionLog_impl();
+}
+void HybridFtp2::clearSessionLog_impl() {
+  this->ck().ClearSessionLog();
+}
+
+void HybridFtp2::connect() {
+  this->beginCall();
+  connect_impl();
+}
+void HybridFtp2::connect_impl() {
+  if (!this->ck().Connect()) throw this->fail("connect");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::connectAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.connectAsync", std::move(_parts), [_self]() {
+    _self->connect_impl();
+  });
+}
+
+void HybridFtp2::connectOnly() {
+  this->beginCall();
+  connectOnly_impl();
+}
+void HybridFtp2::connectOnly_impl() {
+  if (!this->ck().ConnectOnly()) throw this->fail("connectOnly");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::connectOnlyAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.connectOnlyAsync", std::move(_parts), [_self]() {
+    _self->connectOnly_impl();
+  });
+}
+
+void HybridFtp2::convertToTls() {
+  this->beginCall();
+  convertToTls_impl();
+}
+void HybridFtp2::convertToTls_impl() {
+  if (!this->ck().ConvertToTls()) throw this->fail("convertToTls");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::convertToTlsAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.convertToTlsAsync", std::move(_parts), [_self]() {
+    _self->convertToTls_impl();
+  });
+}
+
+std::string HybridFtp2::createPlan(const std::string& localDir) {
+  this->beginCall();
+  return createPlan_impl(localDir);
+}
+std::string HybridFtp2::createPlan_impl(const std::string& localDir) {
+  rt::checkNoNul(localDir, "localDir");
+  CkString _out;
+  if (!this->ck().CreatePlan(localDir.c_str(), _out)) throw this->fail("createPlan");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::createPlanAsync(const std::string& localDir) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.createPlanAsync", std::move(_parts), [_self, localDir]() {
+    return _self->createPlan_impl(localDir);
+  });
+}
+
+void HybridFtp2::createRemoteDir(const std::string& remoteDirPath) {
+  this->beginCall();
+  createRemoteDir_impl(remoteDirPath);
+}
+void HybridFtp2::createRemoteDir_impl(const std::string& remoteDirPath) {
+  rt::checkNoNul(remoteDirPath, "remoteDirPath");
+  if (!this->ck().CreateRemoteDir(remoteDirPath.c_str())) throw this->fail("createRemoteDir");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::createRemoteDirAsync(const std::string& remoteDirPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.createRemoteDirAsync", std::move(_parts), [_self, remoteDirPath]() {
+    _self->createRemoteDir_impl(remoteDirPath);
+  });
+}
+
+double HybridFtp2::deleteMatching(const std::string& remotePattern) {
+  this->beginCall();
+  return deleteMatching_impl(remotePattern);
+}
+double HybridFtp2::deleteMatching_impl(const std::string& remotePattern) {
+  rt::checkNoNul(remotePattern, "remotePattern");
+  return static_cast<double>(this->ck().DeleteMatching(remotePattern.c_str()));
+}
+std::shared_ptr<Promise<double>> HybridFtp2::deleteMatchingAsync(const std::string& remotePattern) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ftp2.deleteMatchingAsync", std::move(_parts), [_self, remotePattern]() {
+    return _self->deleteMatching_impl(remotePattern);
+  });
+}
+
+void HybridFtp2::deleteRemoteFile(const std::string& remoteFilePath) {
+  this->beginCall();
+  deleteRemoteFile_impl(remoteFilePath);
+}
+void HybridFtp2::deleteRemoteFile_impl(const std::string& remoteFilePath) {
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  if (!this->ck().DeleteRemoteFile(remoteFilePath.c_str())) throw this->fail("deleteRemoteFile");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::deleteRemoteFileAsync(const std::string& remoteFilePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.deleteRemoteFileAsync", std::move(_parts), [_self, remoteFilePath]() {
+    _self->deleteRemoteFile_impl(remoteFilePath);
+  });
+}
+
+void HybridFtp2::deleteTree() {
+  this->beginCall();
+  deleteTree_impl();
+}
+void HybridFtp2::deleteTree_impl() {
+  if (!this->ck().DeleteTree()) throw this->fail("deleteTree");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::deleteTreeAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.deleteTreeAsync", std::move(_parts), [_self]() {
+    _self->deleteTree_impl();
+  });
+}
+
+std::string HybridFtp2::dirTreeXml() {
+  this->beginCall();
+  return dirTreeXml_impl();
+}
+std::string HybridFtp2::dirTreeXml_impl() {
+  CkString _out;
+  if (!this->ck().DirTreeXml(_out)) throw this->fail("dirTreeXml");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::dirTreeXmlAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.dirTreeXmlAsync", std::move(_parts), [_self]() {
+    return _self->dirTreeXml_impl();
+  });
+}
+
+void HybridFtp2::disconnect() {
+  this->beginCall();
+  disconnect_impl();
+}
+void HybridFtp2::disconnect_impl() {
+  if (!this->ck().Disconnect()) throw this->fail("disconnect");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::disconnectAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.disconnectAsync", std::move(_parts), [_self]() {
+    _self->disconnect_impl();
+  });
+}
+
+void HybridFtp2::downloadTree(const std::string& localRoot) {
+  this->beginCall();
+  downloadTree_impl(localRoot);
+}
+void HybridFtp2::downloadTree_impl(const std::string& localRoot) {
+  rt::checkNoNul(localRoot, "localRoot");
+  if (!this->ck().DownloadTree(localRoot.c_str())) throw this->fail("downloadTree");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::downloadTreeAsync(const std::string& localRoot) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.downloadTreeAsync", std::move(_parts), [_self, localRoot]() {
+    _self->downloadTree_impl(localRoot);
+  });
+}
+
+std::string HybridFtp2::feat() {
+  this->beginCall();
+  return feat_impl();
+}
+std::string HybridFtp2::feat_impl() {
+  CkString _out;
+  if (!this->ck().Feat(_out)) throw this->fail("feat");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::featAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.featAsync", std::move(_parts), [_self]() {
+    return _self->feat_impl();
+  });
+}
+
+std::string HybridFtp2::getCreateTimeByNameStr(const std::string& filename) {
+  this->beginCall();
+  return getCreateTimeByNameStr_impl(filename);
+}
+std::string HybridFtp2::getCreateTimeByNameStr_impl(const std::string& filename) {
+  rt::checkNoNul(filename, "filename");
+  CkString _out;
+  if (!this->ck().GetCreateTimeByNameStr(filename.c_str(), _out)) throw this->fail("getCreateTimeByNameStr");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getCreateTimeByNameStrAsync(const std::string& filename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getCreateTimeByNameStrAsync", std::move(_parts), [_self, filename]() {
+    return _self->getCreateTimeByNameStr_impl(filename);
+  });
+}
+
+std::string HybridFtp2::getCreateTimeStr(double index) {
+  this->beginCall();
+  return getCreateTimeStr_impl(index);
+}
+std::string HybridFtp2::getCreateTimeStr_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetCreateTimeStr(rt::toInt(index, "index"), _out)) throw this->fail("getCreateTimeStr");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getCreateTimeStrAsync(double index) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getCreateTimeStrAsync", std::move(_parts), [_self, index]() {
+    return _self->getCreateTimeStr_impl(index);
+  });
+}
+
+std::string HybridFtp2::getCurrentRemoteDir() {
+  this->beginCall();
+  return getCurrentRemoteDir_impl();
+}
+std::string HybridFtp2::getCurrentRemoteDir_impl() {
+  CkString _out;
+  if (!this->ck().GetCurrentRemoteDir(_out)) throw this->fail("getCurrentRemoteDir");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getCurrentRemoteDirAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getCurrentRemoteDirAsync", std::move(_parts), [_self]() {
+    return _self->getCurrentRemoteDir_impl();
+  });
+}
+
+double HybridFtp2::getDirCount() {
+  this->beginCall();
+  return getDirCount_impl();
+}
+double HybridFtp2::getDirCount_impl() {
+  return static_cast<double>(this->ck().GetDirCount());
+}
+std::shared_ptr<Promise<double>> HybridFtp2::getDirCountAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ftp2.getDirCountAsync", std::move(_parts), [_self]() {
+    return _self->getDirCount_impl();
+  });
+}
+
+void HybridFtp2::getFile(const std::string& remoteFilePath, const std::string& localFilePath) {
+  this->beginCall();
+  getFile_impl(remoteFilePath, localFilePath);
+}
+void HybridFtp2::getFile_impl(const std::string& remoteFilePath, const std::string& localFilePath) {
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  rt::checkNoNul(localFilePath, "localFilePath");
+  if (!this->ck().GetFile(remoteFilePath.c_str(), localFilePath.c_str())) throw this->fail("getFile");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::getFileAsync(const std::string& remoteFilePath, const std::string& localFilePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.getFileAsync", std::move(_parts), [_self, remoteFilePath, localFilePath]() {
+    _self->getFile_impl(remoteFilePath, localFilePath);
+  });
+}
+
+std::string HybridFtp2::getFilename(double index) {
+  this->beginCall();
+  return getFilename_impl(index);
+}
+std::string HybridFtp2::getFilename_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetFilename(rt::toInt(index, "index"), _out)) throw this->fail("getFilename");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getFilenameAsync(double index) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getFilenameAsync", std::move(_parts), [_self, index]() {
+    return _self->getFilename_impl(index);
+  });
+}
+
+std::string HybridFtp2::getGroup(double index) {
+  this->beginCall();
+  return getGroup_impl(index);
+}
+std::string HybridFtp2::getGroup_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetGroup(rt::toInt(index, "index"), _out)) throw this->fail("getGroup");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getGroupAsync(double index) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getGroupAsync", std::move(_parts), [_self, index]() {
+    return _self->getGroup_impl(index);
+  });
+}
+
+bool HybridFtp2::getIsDirectory(double index) {
+  this->beginCall();
+  return getIsDirectory_impl(index);
+}
+bool HybridFtp2::getIsDirectory_impl(double index) {
+  return this->ck().GetIsDirectory(rt::toInt(index, "index"));
+}
+std::shared_ptr<Promise<bool>> HybridFtp2::getIsDirectoryAsync(double index) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<bool>("Ftp2.getIsDirectoryAsync", std::move(_parts), [_self, index]() {
+    return _self->getIsDirectory_impl(index);
+  });
+}
+
+bool HybridFtp2::getIsSymbolicLink(double index) {
+  this->beginCall();
+  return getIsSymbolicLink_impl(index);
+}
+bool HybridFtp2::getIsSymbolicLink_impl(double index) {
+  return this->ck().GetIsSymbolicLink(rt::toInt(index, "index"));
+}
+std::shared_ptr<Promise<bool>> HybridFtp2::getIsSymbolicLinkAsync(double index) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<bool>("Ftp2.getIsSymbolicLinkAsync", std::move(_parts), [_self, index]() {
+    return _self->getIsSymbolicLink_impl(index);
+  });
+}
+
+std::string HybridFtp2::getLastModifiedTimeByNameStr(const std::string& filename) {
+  this->beginCall();
+  return getLastModifiedTimeByNameStr_impl(filename);
+}
+std::string HybridFtp2::getLastModifiedTimeByNameStr_impl(const std::string& filename) {
+  rt::checkNoNul(filename, "filename");
+  CkString _out;
+  if (!this->ck().GetLastModifiedTimeByNameStr(filename.c_str(), _out)) throw this->fail("getLastModifiedTimeByNameStr");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getLastModifiedTimeByNameStrAsync(const std::string& filename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getLastModifiedTimeByNameStrAsync", std::move(_parts), [_self, filename]() {
+    return _self->getLastModifiedTimeByNameStr_impl(filename);
+  });
+}
+
+std::string HybridFtp2::getLastModifiedTimeStr(double index) {
+  this->beginCall();
+  return getLastModifiedTimeStr_impl(index);
+}
+std::string HybridFtp2::getLastModifiedTimeStr_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetLastModifiedTimeStr(rt::toInt(index, "index"), _out)) throw this->fail("getLastModifiedTimeStr");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getLastModifiedTimeStrAsync(double index) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getLastModifiedTimeStrAsync", std::move(_parts), [_self, index]() {
+    return _self->getLastModifiedTimeStr_impl(index);
+  });
+}
+
+std::string HybridFtp2::getOwner(double index) {
+  this->beginCall();
+  return getOwner_impl(index);
+}
+std::string HybridFtp2::getOwner_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetOwner(rt::toInt(index, "index"), _out)) throw this->fail("getOwner");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getOwnerAsync(double index) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getOwnerAsync", std::move(_parts), [_self, index]() {
+    return _self->getOwner_impl(index);
+  });
+}
+
+std::string HybridFtp2::getPermType(double index) {
+  this->beginCall();
+  return getPermType_impl(index);
+}
+std::string HybridFtp2::getPermType_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetPermType(rt::toInt(index, "index"), _out)) throw this->fail("getPermType");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getPermTypeAsync(double index) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getPermTypeAsync", std::move(_parts), [_self, index]() {
+    return _self->getPermType_impl(index);
+  });
+}
+
+std::string HybridFtp2::getPermissions(double index) {
+  this->beginCall();
+  return getPermissions_impl(index);
+}
+std::string HybridFtp2::getPermissions_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetPermissions(rt::toInt(index, "index"), _out)) throw this->fail("getPermissions");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getPermissionsAsync(double index) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getPermissionsAsync", std::move(_parts), [_self, index]() {
+    return _self->getPermissions_impl(index);
+  });
+}
+
+std::string HybridFtp2::getRemoteFileTextC(const std::string& remoteFilename, const std::string& charset) {
+  this->beginCall();
+  return getRemoteFileTextC_impl(remoteFilename, charset);
+}
+std::string HybridFtp2::getRemoteFileTextC_impl(const std::string& remoteFilename, const std::string& charset) {
+  rt::checkNoNul(remoteFilename, "remoteFilename");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().GetRemoteFileTextC(remoteFilename.c_str(), charset.c_str(), _out)) throw this->fail("getRemoteFileTextC");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getRemoteFileTextCAsync(const std::string& remoteFilename, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getRemoteFileTextCAsync", std::move(_parts), [_self, remoteFilename, charset]() {
+    return _self->getRemoteFileTextC_impl(remoteFilename, charset);
+  });
+}
+
+std::string HybridFtp2::getRemoteFileTextData(const std::string& remoteFilename) {
+  this->beginCall();
+  return getRemoteFileTextData_impl(remoteFilename);
+}
+std::string HybridFtp2::getRemoteFileTextData_impl(const std::string& remoteFilename) {
+  rt::checkNoNul(remoteFilename, "remoteFilename");
+  CkString _out;
+  if (!this->ck().GetRemoteFileTextData(remoteFilename.c_str(), _out)) throw this->fail("getRemoteFileTextData");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getRemoteFileTextDataAsync(const std::string& remoteFilename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getRemoteFileTextDataAsync", std::move(_parts), [_self, remoteFilename]() {
+    return _self->getRemoteFileTextData_impl(remoteFilename);
+  });
+}
+
+double HybridFtp2::getSize(double index) {
+  this->beginCall();
+  return getSize_impl(index);
+}
+double HybridFtp2::getSize_impl(double index) {
+  return static_cast<double>(this->ck().GetSize(rt::toInt(index, "index")));
+}
+std::shared_ptr<Promise<double>> HybridFtp2::getSizeAsync(double index) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ftp2.getSizeAsync", std::move(_parts), [_self, index]() {
+    return _self->getSize_impl(index);
+  });
+}
+
+double HybridFtp2::getSize64(double index) {
+  this->beginCall();
+  return getSize64_impl(index);
+}
+double HybridFtp2::getSize64_impl(double index) {
+  return static_cast<double>(this->ck().GetSize64(rt::toInt(index, "index")));
+}
+std::shared_ptr<Promise<double>> HybridFtp2::getSize64Async(double index) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ftp2.getSize64Async", std::move(_parts), [_self, index]() {
+    return _self->getSize64_impl(index);
+  });
+}
+
+double HybridFtp2::getSizeByName(const std::string& filename) {
+  this->beginCall();
+  return getSizeByName_impl(filename);
+}
+double HybridFtp2::getSizeByName_impl(const std::string& filename) {
+  rt::checkNoNul(filename, "filename");
+  return static_cast<double>(this->ck().GetSizeByName(filename.c_str()));
+}
+std::shared_ptr<Promise<double>> HybridFtp2::getSizeByNameAsync(const std::string& filename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ftp2.getSizeByNameAsync", std::move(_parts), [_self, filename]() {
+    return _self->getSizeByName_impl(filename);
+  });
+}
+
+double HybridFtp2::getSizeByName64(const std::string& filename) {
+  this->beginCall();
+  return getSizeByName64_impl(filename);
+}
+double HybridFtp2::getSizeByName64_impl(const std::string& filename) {
+  rt::checkNoNul(filename, "filename");
+  return static_cast<double>(this->ck().GetSizeByName64(filename.c_str()));
+}
+std::shared_ptr<Promise<double>> HybridFtp2::getSizeByName64Async(const std::string& filename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ftp2.getSizeByName64Async", std::move(_parts), [_self, filename]() {
+    return _self->getSizeByName64_impl(filename);
+  });
+}
+
+std::string HybridFtp2::getSizeStr(double index) {
+  this->beginCall();
+  return getSizeStr_impl(index);
+}
+std::string HybridFtp2::getSizeStr_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetSizeStr(rt::toInt(index, "index"), _out)) throw this->fail("getSizeStr");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getSizeStrAsync(double index) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getSizeStrAsync", std::move(_parts), [_self, index]() {
+    return _self->getSizeStr_impl(index);
+  });
+}
+
+std::string HybridFtp2::getSizeStrByName(const std::string& filename) {
+  this->beginCall();
+  return getSizeStrByName_impl(filename);
+}
+std::string HybridFtp2::getSizeStrByName_impl(const std::string& filename) {
+  rt::checkNoNul(filename, "filename");
+  CkString _out;
+  if (!this->ck().GetSizeStrByName(filename.c_str(), _out)) throw this->fail("getSizeStrByName");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getSizeStrByNameAsync(const std::string& filename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getSizeStrByNameAsync", std::move(_parts), [_self, filename]() {
+    return _self->getSizeStrByName_impl(filename);
+  });
+}
+
+std::string HybridFtp2::getTextDirListing(const std::string& pattern) {
+  this->beginCall();
+  return getTextDirListing_impl(pattern);
+}
+std::string HybridFtp2::getTextDirListing_impl(const std::string& pattern) {
+  rt::checkNoNul(pattern, "pattern");
+  CkString _out;
+  if (!this->ck().GetTextDirListing(pattern.c_str(), _out)) throw this->fail("getTextDirListing");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getTextDirListingAsync(const std::string& pattern) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getTextDirListingAsync", std::move(_parts), [_self, pattern]() {
+    return _self->getTextDirListing_impl(pattern);
+  });
+}
+
+std::string HybridFtp2::getXmlDirListing(const std::string& pattern) {
+  this->beginCall();
+  return getXmlDirListing_impl(pattern);
+}
+std::string HybridFtp2::getXmlDirListing_impl(const std::string& pattern) {
+  rt::checkNoNul(pattern, "pattern");
+  CkString _out;
+  if (!this->ck().GetXmlDirListing(pattern.c_str(), _out)) throw this->fail("getXmlDirListing");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::getXmlDirListingAsync(const std::string& pattern) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.getXmlDirListingAsync", std::move(_parts), [_self, pattern]() {
+    return _self->getXmlDirListing_impl(pattern);
+  });
+}
+
+void HybridFtp2::largeFileUpload(const std::string& localPath, const std::string& remotePath, double chunkSize) {
+  this->beginCall();
+  largeFileUpload_impl(localPath, remotePath, chunkSize);
+}
+void HybridFtp2::largeFileUpload_impl(const std::string& localPath, const std::string& remotePath, double chunkSize) {
+  rt::checkNoNul(localPath, "localPath");
+  rt::checkNoNul(remotePath, "remotePath");
+  if (!this->ck().LargeFileUpload(localPath.c_str(), remotePath.c_str(), rt::toInt(chunkSize, "chunkSize"))) throw this->fail("largeFileUpload");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::largeFileUploadAsync(const std::string& localPath, const std::string& remotePath, double chunkSize) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.largeFileUploadAsync", std::move(_parts), [_self, localPath, remotePath, chunkSize]() {
+    _self->largeFileUpload_impl(localPath, remotePath, chunkSize);
+  });
+}
+
+void HybridFtp2::loginAfterConnectOnly() {
+  this->beginCall();
+  loginAfterConnectOnly_impl();
+}
+void HybridFtp2::loginAfterConnectOnly_impl() {
+  if (!this->ck().LoginAfterConnectOnly()) throw this->fail("loginAfterConnectOnly");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::loginAfterConnectOnlyAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.loginAfterConnectOnlyAsync", std::move(_parts), [_self]() {
+    _self->loginAfterConnectOnly_impl();
+  });
+}
+
+double HybridFtp2::mGetFiles(const std::string& remotePattern, const std::string& localDir) {
+  this->beginCall();
+  return mGetFiles_impl(remotePattern, localDir);
+}
+double HybridFtp2::mGetFiles_impl(const std::string& remotePattern, const std::string& localDir) {
+  rt::checkNoNul(remotePattern, "remotePattern");
+  rt::checkNoNul(localDir, "localDir");
+  return static_cast<double>(this->ck().MGetFiles(remotePattern.c_str(), localDir.c_str()));
+}
+std::shared_ptr<Promise<double>> HybridFtp2::mGetFilesAsync(const std::string& remotePattern, const std::string& localDir) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ftp2.mGetFilesAsync", std::move(_parts), [_self, remotePattern, localDir]() {
+    return _self->mGetFiles_impl(remotePattern, localDir);
+  });
+}
+
+double HybridFtp2::mPutFiles(const std::string& pattern) {
+  this->beginCall();
+  return mPutFiles_impl(pattern);
+}
+double HybridFtp2::mPutFiles_impl(const std::string& pattern) {
+  rt::checkNoNul(pattern, "pattern");
+  return static_cast<double>(this->ck().MPutFiles(pattern.c_str()));
+}
+std::shared_ptr<Promise<double>> HybridFtp2::mPutFilesAsync(const std::string& pattern) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ftp2.mPutFilesAsync", std::move(_parts), [_self, pattern]() {
+    return _self->mPutFiles_impl(pattern);
+  });
+}
+
+std::string HybridFtp2::nlstXml(const std::string& remoteDirPattern) {
+  this->beginCall();
+  return nlstXml_impl(remoteDirPattern);
+}
+std::string HybridFtp2::nlstXml_impl(const std::string& remoteDirPattern) {
+  rt::checkNoNul(remoteDirPattern, "remoteDirPattern");
+  CkString _out;
+  if (!this->ck().NlstXml(remoteDirPattern.c_str(), _out)) throw this->fail("nlstXml");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::nlstXmlAsync(const std::string& remoteDirPattern) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.nlstXmlAsync", std::move(_parts), [_self, remoteDirPattern]() {
+    return _self->nlstXml_impl(remoteDirPattern);
+  });
+}
+
+void HybridFtp2::noop() {
+  this->beginCall();
+  noop_impl();
+}
+void HybridFtp2::noop_impl() {
+  if (!this->ck().Noop()) throw this->fail("noop");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::noopAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.noopAsync", std::move(_parts), [_self]() {
+    _self->noop_impl();
+  });
+}
+
+void HybridFtp2::putFile(const std::string& localFilePath, const std::string& remoteFilePath) {
+  this->beginCall();
+  putFile_impl(localFilePath, remoteFilePath);
+}
+void HybridFtp2::putFile_impl(const std::string& localFilePath, const std::string& remoteFilePath) {
+  rt::checkNoNul(localFilePath, "localFilePath");
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  if (!this->ck().PutFile(localFilePath.c_str(), remoteFilePath.c_str())) throw this->fail("putFile");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::putFileAsync(const std::string& localFilePath, const std::string& remoteFilePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.putFileAsync", std::move(_parts), [_self, localFilePath, remoteFilePath]() {
+    _self->putFile_impl(localFilePath, remoteFilePath);
+  });
+}
+
+void HybridFtp2::putFileFromTextData(const std::string& remoteFilename, const std::string& textData, const std::string& charset) {
+  this->beginCall();
+  putFileFromTextData_impl(remoteFilename, textData, charset);
+}
+void HybridFtp2::putFileFromTextData_impl(const std::string& remoteFilename, const std::string& textData, const std::string& charset) {
+  rt::checkNoNul(remoteFilename, "remoteFilename");
+  rt::checkNoNul(textData, "textData");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().PutFileFromTextData(remoteFilename.c_str(), textData.c_str(), charset.c_str())) throw this->fail("putFileFromTextData");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::putFileFromTextDataAsync(const std::string& remoteFilename, const std::string& textData, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.putFileFromTextDataAsync", std::move(_parts), [_self, remoteFilename, textData, charset]() {
+    _self->putFileFromTextData_impl(remoteFilename, textData, charset);
+  });
+}
+
+void HybridFtp2::putPlan(const std::string& plan, const std::string& alreadyDoneFilename) {
+  this->beginCall();
+  putPlan_impl(plan, alreadyDoneFilename);
+}
+void HybridFtp2::putPlan_impl(const std::string& plan, const std::string& alreadyDoneFilename) {
+  rt::checkNoNul(plan, "plan");
+  rt::checkNoNul(alreadyDoneFilename, "alreadyDoneFilename");
+  if (!this->ck().PutPlan(plan.c_str(), alreadyDoneFilename.c_str())) throw this->fail("putPlan");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::putPlanAsync(const std::string& plan, const std::string& alreadyDoneFilename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.putPlanAsync", std::move(_parts), [_self, plan, alreadyDoneFilename]() {
+    _self->putPlan_impl(plan, alreadyDoneFilename);
+  });
+}
+
+void HybridFtp2::putTree(const std::string& localDir) {
+  this->beginCall();
+  putTree_impl(localDir);
+}
+void HybridFtp2::putTree_impl(const std::string& localDir) {
+  rt::checkNoNul(localDir, "localDir");
+  if (!this->ck().PutTree(localDir.c_str())) throw this->fail("putTree");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::putTreeAsync(const std::string& localDir) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.putTreeAsync", std::move(_parts), [_self, localDir]() {
+    _self->putTree_impl(localDir);
+  });
+}
+
+void HybridFtp2::quote(const std::string& cmd) {
+  this->beginCall();
+  quote_impl(cmd);
+}
+void HybridFtp2::quote_impl(const std::string& cmd) {
+  rt::checkNoNul(cmd, "cmd");
+  if (!this->ck().Quote(cmd.c_str())) throw this->fail("quote");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::quoteAsync(const std::string& cmd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.quoteAsync", std::move(_parts), [_self, cmd]() {
+    _self->quote_impl(cmd);
+  });
+}
+
+void HybridFtp2::removeRemoteDir(const std::string& remoteDirPath) {
+  this->beginCall();
+  removeRemoteDir_impl(remoteDirPath);
+}
+void HybridFtp2::removeRemoteDir_impl(const std::string& remoteDirPath) {
+  rt::checkNoNul(remoteDirPath, "remoteDirPath");
+  if (!this->ck().RemoveRemoteDir(remoteDirPath.c_str())) throw this->fail("removeRemoteDir");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::removeRemoteDirAsync(const std::string& remoteDirPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.removeRemoteDirAsync", std::move(_parts), [_self, remoteDirPath]() {
+    _self->removeRemoteDir_impl(remoteDirPath);
+  });
+}
+
+void HybridFtp2::renameRemoteFile(const std::string& existingRemoteFilePath, const std::string& newRemoteFilePath) {
+  this->beginCall();
+  renameRemoteFile_impl(existingRemoteFilePath, newRemoteFilePath);
+}
+void HybridFtp2::renameRemoteFile_impl(const std::string& existingRemoteFilePath, const std::string& newRemoteFilePath) {
+  rt::checkNoNul(existingRemoteFilePath, "existingRemoteFilePath");
+  rt::checkNoNul(newRemoteFilePath, "newRemoteFilePath");
+  if (!this->ck().RenameRemoteFile(existingRemoteFilePath.c_str(), newRemoteFilePath.c_str())) throw this->fail("renameRemoteFile");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::renameRemoteFileAsync(const std::string& existingRemoteFilePath, const std::string& newRemoteFilePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.renameRemoteFileAsync", std::move(_parts), [_self, existingRemoteFilePath, newRemoteFilePath]() {
+    _self->renameRemoteFile_impl(existingRemoteFilePath, newRemoteFilePath);
+  });
+}
+
+std::string HybridFtp2::sendCommand(const std::string& cmd) {
+  this->beginCall();
+  return sendCommand_impl(cmd);
+}
+std::string HybridFtp2::sendCommand_impl(const std::string& cmd) {
+  rt::checkNoNul(cmd, "cmd");
+  CkString _out;
+  if (!this->ck().SendCommand(cmd.c_str(), _out)) throw this->fail("sendCommand");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::sendCommandAsync(const std::string& cmd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.sendCommandAsync", std::move(_parts), [_self, cmd]() {
+    return _self->sendCommand_impl(cmd);
+  });
+}
+
+void HybridFtp2::setModeZ() {
+  this->beginCall();
+  setModeZ_impl();
+}
+void HybridFtp2::setModeZ_impl() {
+  if (!this->ck().SetModeZ()) throw this->fail("setModeZ");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::setModeZAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.setModeZAsync", std::move(_parts), [_self]() {
+    _self->setModeZ_impl();
+  });
+}
+
+void HybridFtp2::setOldestDateStr(const std::string& oldestDateTimeStr) {
+  this->beginCall();
+  setOldestDateStr_impl(oldestDateTimeStr);
+}
+void HybridFtp2::setOldestDateStr_impl(const std::string& oldestDateTimeStr) {
+  rt::checkNoNul(oldestDateTimeStr, "oldestDateTimeStr");
+  this->ck().SetOldestDateStr(oldestDateTimeStr.c_str());
+}
+
+void HybridFtp2::setOption(const std::string& optionName) {
+  this->beginCall();
+  setOption_impl(optionName);
+}
+void HybridFtp2::setOption_impl(const std::string& optionName) {
+  rt::checkNoNul(optionName, "optionName");
+  if (!this->ck().SetOption(optionName.c_str())) throw this->fail("setOption");
+}
+
+void HybridFtp2::setRemoteFileDateTimeStr(const std::string& dateTimeStr, const std::string& remoteFilename) {
+  this->beginCall();
+  setRemoteFileDateTimeStr_impl(dateTimeStr, remoteFilename);
+}
+void HybridFtp2::setRemoteFileDateTimeStr_impl(const std::string& dateTimeStr, const std::string& remoteFilename) {
+  rt::checkNoNul(dateTimeStr, "dateTimeStr");
+  rt::checkNoNul(remoteFilename, "remoteFilename");
+  if (!this->ck().SetRemoteFileDateTimeStr(dateTimeStr.c_str(), remoteFilename.c_str())) throw this->fail("setRemoteFileDateTimeStr");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::setRemoteFileDateTimeStrAsync(const std::string& dateTimeStr, const std::string& remoteFilename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.setRemoteFileDateTimeStrAsync", std::move(_parts), [_self, dateTimeStr, remoteFilename]() {
+    _self->setRemoteFileDateTimeStr_impl(dateTimeStr, remoteFilename);
+  });
+}
+
+void HybridFtp2::setRemoteFileDt(const std::shared_ptr<HybridCkDateTimeSpec>& dt, const std::string& remoteFilename) {
+  this->beginCall();
+  setRemoteFileDt_impl(dt, remoteFilename);
+}
+void HybridFtp2::setRemoteFileDt_impl(const std::shared_ptr<HybridCkDateTimeSpec>& dt, const std::string& remoteFilename) {
+  rt::checkNoNul(remoteFilename, "remoteFilename");
+  if (!this->ck().SetRemoteFileDt(rt::implOf<HybridCkDateTime>(dt, "dt").ck(), remoteFilename.c_str())) throw this->fail("setRemoteFileDt");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::setRemoteFileDtAsync(const std::shared_ptr<HybridCkDateTimeSpec>& dt, const std::string& remoteFilename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(dt);
+  return rt::runAsync<void>("Ftp2.setRemoteFileDtAsync", std::move(_parts), [_self, dt, remoteFilename]() {
+    _self->setRemoteFileDt_impl(dt, remoteFilename);
+  });
+}
+
+void HybridFtp2::setSslCertRequirement(const std::string& reqName, const std::string& reqValue) {
+  this->beginCall();
+  setSslCertRequirement_impl(reqName, reqValue);
+}
+void HybridFtp2::setSslCertRequirement_impl(const std::string& reqName, const std::string& reqValue) {
+  rt::checkNoNul(reqName, "reqName");
+  rt::checkNoNul(reqValue, "reqValue");
+  this->ck().SetSslCertRequirement(reqName.c_str(), reqValue.c_str());
+}
+
+void HybridFtp2::setSslClientCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setSslClientCert_impl(cert);
+}
+void HybridFtp2::setSslClientCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetSslClientCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setSslClientCert");
+}
+
+void HybridFtp2::setSslClientCertPem(const std::string& pemDataOrFilename, const std::string& pemPassword) {
+  this->beginCall();
+  setSslClientCertPem_impl(pemDataOrFilename, pemPassword);
+}
+void HybridFtp2::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 HybridFtp2::setSslClientCertPfx(const std::string& pfxFilename, const std::string& pfxPassword) {
+  this->beginCall();
+  setSslClientCertPfx_impl(pfxFilename, pfxPassword);
+}
+void HybridFtp2::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 HybridFtp2::setTypeAscii() {
+  this->beginCall();
+  setTypeAscii_impl();
+}
+void HybridFtp2::setTypeAscii_impl() {
+  if (!this->ck().SetTypeAscii()) throw this->fail("setTypeAscii");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::setTypeAsciiAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.setTypeAsciiAsync", std::move(_parts), [_self]() {
+    _self->setTypeAscii_impl();
+  });
+}
+
+void HybridFtp2::setTypeBinary() {
+  this->beginCall();
+  setTypeBinary_impl();
+}
+void HybridFtp2::setTypeBinary_impl() {
+  if (!this->ck().SetTypeBinary()) throw this->fail("setTypeBinary");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::setTypeBinaryAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.setTypeBinaryAsync", std::move(_parts), [_self]() {
+    _self->setTypeBinary_impl();
+  });
+}
+
+void HybridFtp2::site(const std::string& siteCommand) {
+  this->beginCall();
+  site_impl(siteCommand);
+}
+void HybridFtp2::site_impl(const std::string& siteCommand) {
+  rt::checkNoNul(siteCommand, "siteCommand");
+  if (!this->ck().Site(siteCommand.c_str())) throw this->fail("site");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::siteAsync(const std::string& siteCommand) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.siteAsync", std::move(_parts), [_self, siteCommand]() {
+    _self->site_impl(siteCommand);
+  });
+}
+
+void HybridFtp2::sleepMs(double millisec) {
+  this->beginCall();
+  sleepMs_impl(millisec);
+}
+void HybridFtp2::sleepMs_impl(double millisec) {
+  this->ck().SleepMs(rt::toInt(millisec, "millisec"));
+}
+
+std::string HybridFtp2::stat() {
+  this->beginCall();
+  return stat_impl();
+}
+std::string HybridFtp2::stat_impl() {
+  CkString _out;
+  if (!this->ck().Stat(_out)) throw this->fail("stat");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::statAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.statAsync", std::move(_parts), [_self]() {
+    return _self->stat_impl();
+  });
+}
+
+void HybridFtp2::syncDeleteRemote(const std::string& localRoot) {
+  this->beginCall();
+  syncDeleteRemote_impl(localRoot);
+}
+void HybridFtp2::syncDeleteRemote_impl(const std::string& localRoot) {
+  rt::checkNoNul(localRoot, "localRoot");
+  if (!this->ck().SyncDeleteRemote(localRoot.c_str())) throw this->fail("syncDeleteRemote");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::syncDeleteRemoteAsync(const std::string& localRoot) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.syncDeleteRemoteAsync", std::move(_parts), [_self, localRoot]() {
+    _self->syncDeleteRemote_impl(localRoot);
+  });
+}
+
+void HybridFtp2::syncLocalDir(const std::string& localRoot, double mode) {
+  this->beginCall();
+  syncLocalDir_impl(localRoot, mode);
+}
+void HybridFtp2::syncLocalDir_impl(const std::string& localRoot, double mode) {
+  rt::checkNoNul(localRoot, "localRoot");
+  if (!this->ck().SyncLocalDir(localRoot.c_str(), rt::toInt(mode, "mode"))) throw this->fail("syncLocalDir");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::syncLocalDirAsync(const std::string& localRoot, double mode) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.syncLocalDirAsync", std::move(_parts), [_self, localRoot, mode]() {
+    _self->syncLocalDir_impl(localRoot, mode);
+  });
+}
+
+void HybridFtp2::syncLocalTree(const std::string& localRoot, double mode) {
+  this->beginCall();
+  syncLocalTree_impl(localRoot, mode);
+}
+void HybridFtp2::syncLocalTree_impl(const std::string& localRoot, double mode) {
+  rt::checkNoNul(localRoot, "localRoot");
+  if (!this->ck().SyncLocalTree(localRoot.c_str(), rt::toInt(mode, "mode"))) throw this->fail("syncLocalTree");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::syncLocalTreeAsync(const std::string& localRoot, double mode) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.syncLocalTreeAsync", std::move(_parts), [_self, localRoot, mode]() {
+    _self->syncLocalTree_impl(localRoot, mode);
+  });
+}
+
+void HybridFtp2::syncRemoteTree(const std::string& localRoot, double mode) {
+  this->beginCall();
+  syncRemoteTree_impl(localRoot, mode);
+}
+void HybridFtp2::syncRemoteTree_impl(const std::string& localRoot, double mode) {
+  rt::checkNoNul(localRoot, "localRoot");
+  if (!this->ck().SyncRemoteTree(localRoot.c_str(), rt::toInt(mode, "mode"))) throw this->fail("syncRemoteTree");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::syncRemoteTreeAsync(const std::string& localRoot, double mode) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.syncRemoteTreeAsync", std::move(_parts), [_self, localRoot, mode]() {
+    _self->syncRemoteTree_impl(localRoot, mode);
+  });
+}
+
+void HybridFtp2::syncRemoteTree2(const std::string& localDirPath, double mode, bool bDescend, bool bPreviewOnly) {
+  this->beginCall();
+  syncRemoteTree2_impl(localDirPath, mode, bDescend, bPreviewOnly);
+}
+void HybridFtp2::syncRemoteTree2_impl(const std::string& localDirPath, double mode, bool bDescend, bool bPreviewOnly) {
+  rt::checkNoNul(localDirPath, "localDirPath");
+  if (!this->ck().SyncRemoteTree2(localDirPath.c_str(), rt::toInt(mode, "mode"), bDescend, bPreviewOnly)) throw this->fail("syncRemoteTree2");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::syncRemoteTree2Async(const std::string& localDirPath, double mode, bool bDescend, bool bPreviewOnly) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ftp2.syncRemoteTree2Async", std::move(_parts), [_self, localDirPath, mode, bDescend, bPreviewOnly]() {
+    _self->syncRemoteTree2_impl(localDirPath, mode, bDescend, bPreviewOnly);
+  });
+}
+
+std::string HybridFtp2::syst() {
+  this->beginCall();
+  return syst_impl();
+}
+std::string HybridFtp2::syst_impl() {
+  CkString _out;
+  if (!this->ck().Syst(_out)) throw this->fail("syst");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridFtp2::systAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ftp2.systAsync", std::move(_parts), [_self]() {
+    return _self->syst_impl();
+  });
+}
+
+void HybridFtp2::getFileBd(const std::string& remoteFilePath, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  getFileBd_impl(remoteFilePath, binData);
+}
+void HybridFtp2::getFileBd_impl(const std::string& remoteFilePath, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  if (!this->ck().GetFileBd(remoteFilePath.c_str(), rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("getFileBd");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::getFileBdAsync(const std::string& remoteFilePath, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  return rt::runAsync<void>("Ftp2.getFileBdAsync", std::move(_parts), [_self, remoteFilePath, binData]() {
+    _self->getFileBd_impl(remoteFilePath, binData);
+  });
+}
+
+void HybridFtp2::getFileSb(const std::string& remoteFilePath, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  getFileSb_impl(remoteFilePath, charset, sb);
+}
+void HybridFtp2::getFileSb_impl(const std::string& remoteFilePath, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().GetFileSb(remoteFilePath.c_str(), charset.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("getFileSb");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::getFileSbAsync(const std::string& remoteFilePath, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<void>("Ftp2.getFileSbAsync", std::move(_parts), [_self, remoteFilePath, charset, sb]() {
+    _self->getFileSb_impl(remoteFilePath, charset, sb);
+  });
+}
+
+void HybridFtp2::putFileBd(const std::shared_ptr<HybridBinDataSpec>& binData, const std::string& remoteFilePath) {
+  this->beginCall();
+  putFileBd_impl(binData, remoteFilePath);
+}
+void HybridFtp2::putFileBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData, const std::string& remoteFilePath) {
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  if (!this->ck().PutFileBd(rt::implOf<HybridBinData>(binData, "binData").ck(), remoteFilePath.c_str())) throw this->fail("putFileBd");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::putFileBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData, const std::string& remoteFilePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  return rt::runAsync<void>("Ftp2.putFileBdAsync", std::move(_parts), [_self, binData, remoteFilePath]() {
+    _self->putFileBd_impl(binData, remoteFilePath);
+  });
+}
+
+void HybridFtp2::putFileSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset, bool includeBom, const std::string& remoteFilePath) {
+  this->beginCall();
+  putFileSb_impl(sb, charset, includeBom, remoteFilePath);
+}
+void HybridFtp2::putFileSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset, bool includeBom, const std::string& remoteFilePath) {
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  if (!this->ck().PutFileSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck(), charset.c_str(), includeBom, remoteFilePath.c_str())) throw this->fail("putFileSb");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::putFileSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset, bool includeBom, const std::string& remoteFilePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<void>("Ftp2.putFileSbAsync", std::move(_parts), [_self, sb, charset, includeBom, remoteFilePath]() {
+    _self->putFileSb_impl(sb, charset, includeBom, remoteFilePath);
+  });
+}
+
+void HybridFtp2::getFileToStream(const std::string& remoteFilePath, const std::shared_ptr<HybridStreamSpec>& toStream) {
+  this->beginCall();
+  getFileToStream_impl(remoteFilePath, toStream);
+}
+void HybridFtp2::getFileToStream_impl(const std::string& remoteFilePath, const std::shared_ptr<HybridStreamSpec>& toStream) {
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  if (!this->ck().GetFileToStream(remoteFilePath.c_str(), rt::implOf<HybridStream>(toStream, "toStream").ck())) throw this->fail("getFileToStream");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::getFileToStreamAsync(const std::string& remoteFilePath, const std::shared_ptr<HybridStreamSpec>& toStream) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(toStream);
+  return rt::runAsync<void>("Ftp2.getFileToStreamAsync", std::move(_parts), [_self, remoteFilePath, toStream]() {
+    _self->getFileToStream_impl(remoteFilePath, toStream);
+  });
+}
+
+void HybridFtp2::setSecurePassword(const std::shared_ptr<HybridSecureStringSpec>& password) {
+  this->beginCall();
+  setSecurePassword_impl(password);
+}
+void HybridFtp2::setSecurePassword_impl(const std::shared_ptr<HybridSecureStringSpec>& password) {
+  if (!this->ck().SetSecurePassword(rt::implOf<HybridSecureString>(password, "password").ck())) throw this->fail("setSecurePassword");
+}
+
+void HybridFtp2::getSyncedFiles(const std::shared_ptr<HybridStringTableSpec>& strTable) {
+  this->beginCall();
+  getSyncedFiles_impl(strTable);
+}
+void HybridFtp2::getSyncedFiles_impl(const std::shared_ptr<HybridStringTableSpec>& strTable) {
+  this->ck().GetSyncedFiles(rt::implOf<HybridStringTable>(strTable, "strTable").ck());
+}
+
+void HybridFtp2::getServerCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  getServerCert_impl(cert);
+}
+void HybridFtp2::getServerCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().GetServerCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("getServerCert");
+}
+
+void HybridFtp2::appendFileBd(const std::string& remoteFilename, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  appendFileBd_impl(remoteFilename, bd);
+}
+void HybridFtp2::appendFileBd_impl(const std::string& remoteFilename, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(remoteFilename, "remoteFilename");
+  if (!this->ck().AppendFileBd(remoteFilename.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("appendFileBd");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::appendFileBdAsync(const std::string& remoteFilename, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("Ftp2.appendFileBdAsync", std::move(_parts), [_self, remoteFilename, bd]() {
+    _self->appendFileBd_impl(remoteFilename, bd);
+  });
+}
+
+void HybridFtp2::appendFileSb(const std::string& remoteFilename, const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) {
+  this->beginCall();
+  appendFileSb_impl(remoteFilename, sb, charset);
+}
+void HybridFtp2::appendFileSb_impl(const std::string& remoteFilename, const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) {
+  rt::checkNoNul(remoteFilename, "remoteFilename");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().AppendFileSb(remoteFilename.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck(), charset.c_str())) throw this->fail("appendFileSb");
+}
+std::shared_ptr<Promise<void>> HybridFtp2::appendFileSbAsync(const std::string& remoteFilename, const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridFtp2>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<void>("Ftp2.appendFileSbAsync", std::move(_parts), [_self, remoteFilename, sb, charset]() {
+    _self->appendFileSb_impl(remoteFilename, sb, charset);
+  });
+}
+
+void HybridFtp2::getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getLastJsonData_impl(json);
+}
+void HybridFtp2::getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->ck().GetLastJsonData(rt::implOf<HybridJsonObject>(json, "json").ck());
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridFtp2::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridFtp2::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridFtp2::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridFtp2::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridFtp2::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat