@chilkat/react-native 11.6.1

package/cpp/HybridSFtp.cpp

@@ -0,0 +1,1889 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridSFtp.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCkDateTime.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridSFtpDir.hpp"
+#include "HybridSecureString.hpp"
+#include "HybridSsh.hpp"
+#include "HybridSshKey.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridStringTable.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+#include <CkSFtpProgress.h>
+
+namespace margelo::nitro::chilkat {
+
+HybridSFtp::HybridSFtp()
+    : HybridObject(HybridSFtpSpec::TAG), ChilkatObject<CkSFtp>("SFtp", CkSFtp::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridSFtp::HybridSFtp(CkSFtp* owned)
+    : HybridObject(HybridSFtpSpec::TAG), ChilkatObject<CkSFtp>("SFtp", owned) {
+  init();
+}
+
+void HybridSFtp::init() {
+  this->installProgress<ProgressAdapter<CkSFtpProgress>>();
+}
+
+void HybridSFtp::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridSFtp::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSFtp::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSFtp::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSFtp::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSFtp::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridSFtp::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridSFtp::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridSFtp::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridSFtp::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridSFtp::getAuthFailReason() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_AuthFailReason());
+}
+double HybridSFtp::getBandwidthThrottleDown() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_BandwidthThrottleDown());
+}
+void HybridSFtp::setBandwidthThrottleDown(double value) {
+  this->beginCall();
+  this->ck().put_BandwidthThrottleDown(rt::toInt(value, "bandwidthThrottleDown"));
+}
+double HybridSFtp::getBandwidthThrottleUp() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_BandwidthThrottleUp());
+}
+void HybridSFtp::setBandwidthThrottleUp(double value) {
+  this->beginCall();
+  this->ck().put_BandwidthThrottleUp(rt::toInt(value, "bandwidthThrottleUp"));
+}
+std::string HybridSFtp::getClientIdentifier() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ClientIdentifier(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setClientIdentifier(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "clientIdentifier");
+  this->ck().put_ClientIdentifier(value.c_str());
+}
+std::string HybridSFtp::getClientIpAddress() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ClientIpAddress(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setClientIpAddress(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "clientIpAddress");
+  this->ck().put_ClientIpAddress(value.c_str());
+}
+double HybridSFtp::getConnectTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectTimeoutMs());
+}
+void HybridSFtp::setConnectTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_ConnectTimeoutMs(rt::toInt(value, "connectTimeoutMs"));
+}
+double HybridSFtp::getDisconnectCode() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_DisconnectCode());
+}
+std::string HybridSFtp::getDisconnectReason() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DisconnectReason(_s);
+  return rt::stdString(_s);
+}
+bool HybridSFtp::getEnableCache() {
+  this->beginCall();
+  return this->ck().get_EnableCache();
+}
+void HybridSFtp::setEnableCache(bool value) {
+  this->beginCall();
+  this->ck().put_EnableCache(value);
+}
+bool HybridSFtp::getEnableCompression() {
+  this->beginCall();
+  return this->ck().get_EnableCompression();
+}
+void HybridSFtp::setEnableCompression(bool value) {
+  this->beginCall();
+  this->ck().put_EnableCompression(value);
+}
+std::string HybridSFtp::getFilenameCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FilenameCharset(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setFilenameCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "filenameCharset");
+  this->ck().put_FilenameCharset(value.c_str());
+}
+std::string HybridSFtp::getForceCipher() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ForceCipher(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setForceCipher(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "forceCipher");
+  this->ck().put_ForceCipher(value.c_str());
+}
+bool HybridSFtp::getForceV3() {
+  this->beginCall();
+  return this->ck().get_ForceV3();
+}
+void HybridSFtp::setForceV3(bool value) {
+  this->beginCall();
+  this->ck().put_ForceV3(value);
+}
+double HybridSFtp::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridSFtp::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+std::string HybridSFtp::getHostKeyAlg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HostKeyAlg(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setHostKeyAlg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "hostKeyAlg");
+  this->ck().put_HostKeyAlg(value.c_str());
+}
+std::string HybridSFtp::getHostKeyFingerprint() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HostKeyFingerprint(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSFtp::getHttpProxyAuthMethod() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyAuthMethod(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setHttpProxyAuthMethod(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyAuthMethod");
+  this->ck().put_HttpProxyAuthMethod(value.c_str());
+}
+std::string HybridSFtp::getHttpProxyDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyDomain(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setHttpProxyDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyDomain");
+  this->ck().put_HttpProxyDomain(value.c_str());
+}
+std::string HybridSFtp::getHttpProxyHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setHttpProxyHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyHostname");
+  this->ck().put_HttpProxyHostname(value.c_str());
+}
+std::string HybridSFtp::getHttpProxyPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setHttpProxyPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyPassword");
+  this->ck().put_HttpProxyPassword(value.c_str());
+}
+double HybridSFtp::getHttpProxyPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HttpProxyPort());
+}
+void HybridSFtp::setHttpProxyPort(double value) {
+  this->beginCall();
+  this->ck().put_HttpProxyPort(rt::toInt(value, "httpProxyPort"));
+}
+std::string HybridSFtp::getHttpProxyUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setHttpProxyUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyUsername");
+  this->ck().put_HttpProxyUsername(value.c_str());
+}
+double HybridSFtp::getIdleTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_IdleTimeoutMs());
+}
+void HybridSFtp::setIdleTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_IdleTimeoutMs(rt::toInt(value, "idleTimeoutMs"));
+}
+bool HybridSFtp::getIncludeDotDirs() {
+  this->beginCall();
+  return this->ck().get_IncludeDotDirs();
+}
+void HybridSFtp::setIncludeDotDirs(bool value) {
+  this->beginCall();
+  this->ck().put_IncludeDotDirs(value);
+}
+double HybridSFtp::getInitializeFailCode() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_InitializeFailCode());
+}
+std::string HybridSFtp::getInitializeFailReason() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_InitializeFailReason(_s);
+  return rt::stdString(_s);
+}
+bool HybridSFtp::getIsConnected() {
+  this->beginCall();
+  return this->ck().get_IsConnected();
+}
+bool HybridSFtp::getKeepSessionLog() {
+  this->beginCall();
+  return this->ck().get_KeepSessionLog();
+}
+void HybridSFtp::setKeepSessionLog(bool value) {
+  this->beginCall();
+  this->ck().put_KeepSessionLog(value);
+}
+double HybridSFtp::getMaxPacketSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_MaxPacketSize());
+}
+void HybridSFtp::setMaxPacketSize(double value) {
+  this->beginCall();
+  this->ck().put_MaxPacketSize(rt::toInt(value, "maxPacketSize"));
+}
+bool HybridSFtp::getPasswordChangeRequested() {
+  this->beginCall();
+  return this->ck().get_PasswordChangeRequested();
+}
+double HybridSFtp::getPercentDoneScale() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_PercentDoneScale());
+}
+void HybridSFtp::setPercentDoneScale(double value) {
+  this->beginCall();
+  this->ck().put_PercentDoneScale(rt::toInt(value, "percentDoneScale"));
+}
+bool HybridSFtp::getPreferIpv6() {
+  this->beginCall();
+  return this->ck().get_PreferIpv6();
+}
+void HybridSFtp::setPreferIpv6(bool value) {
+  this->beginCall();
+  this->ck().put_PreferIpv6(value);
+}
+bool HybridSFtp::getPreserveDate() {
+  this->beginCall();
+  return this->ck().get_PreserveDate();
+}
+void HybridSFtp::setPreserveDate(bool value) {
+  this->beginCall();
+  this->ck().put_PreserveDate(value);
+}
+double HybridSFtp::getProtocolVersion() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ProtocolVersion());
+}
+std::string HybridSFtp::getReadDirMustMatch() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ReadDirMustMatch(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setReadDirMustMatch(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "readDirMustMatch");
+  this->ck().put_ReadDirMustMatch(value.c_str());
+}
+std::string HybridSFtp::getReadDirMustNotMatch() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ReadDirMustNotMatch(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setReadDirMustNotMatch(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "readDirMustNotMatch");
+  this->ck().put_ReadDirMustNotMatch(value.c_str());
+}
+std::string HybridSFtp::getSessionLog() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SessionLog(_s);
+  return rt::stdString(_s);
+}
+double HybridSFtp::getSoRcvBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoRcvBuf());
+}
+void HybridSFtp::setSoRcvBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoRcvBuf(rt::toInt(value, "soRcvBuf"));
+}
+double HybridSFtp::getSoSndBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoSndBuf());
+}
+void HybridSFtp::setSoSndBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoSndBuf(rt::toInt(value, "soSndBuf"));
+}
+std::string HybridSFtp::getSocksHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setSocksHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksHostname");
+  this->ck().put_SocksHostname(value.c_str());
+}
+std::string HybridSFtp::getSocksPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setSocksPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksPassword");
+  this->ck().put_SocksPassword(value.c_str());
+}
+double HybridSFtp::getSocksPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksPort());
+}
+void HybridSFtp::setSocksPort(double value) {
+  this->beginCall();
+  this->ck().put_SocksPort(rt::toInt(value, "socksPort"));
+}
+std::string HybridSFtp::getSocksUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setSocksUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksUsername");
+  this->ck().put_SocksUsername(value.c_str());
+}
+double HybridSFtp::getSocksVersion() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksVersion());
+}
+void HybridSFtp::setSocksVersion(double value) {
+  this->beginCall();
+  this->ck().put_SocksVersion(rt::toInt(value, "socksVersion"));
+}
+std::string HybridSFtp::getSyncMustMatch() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SyncMustMatch(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setSyncMustMatch(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "syncMustMatch");
+  this->ck().put_SyncMustMatch(value.c_str());
+}
+std::string HybridSFtp::getSyncMustNotMatch() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SyncMustNotMatch(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setSyncMustNotMatch(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "syncMustNotMatch");
+  this->ck().put_SyncMustNotMatch(value.c_str());
+}
+bool HybridSFtp::getTcpNoDelay() {
+  this->beginCall();
+  return this->ck().get_TcpNoDelay();
+}
+void HybridSFtp::setTcpNoDelay(bool value) {
+  this->beginCall();
+  this->ck().put_TcpNoDelay(value);
+}
+double HybridSFtp::getUploadChunkSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_UploadChunkSize());
+}
+void HybridSFtp::setUploadChunkSize(double value) {
+  this->beginCall();
+  this->ck().put_UploadChunkSize(rt::toInt(value, "uploadChunkSize"));
+}
+bool HybridSFtp::getUtcMode() {
+  this->beginCall();
+  return this->ck().get_UtcMode();
+}
+void HybridSFtp::setUtcMode(bool value) {
+  this->beginCall();
+  this->ck().put_UtcMode(value);
+}
+bool HybridSFtp::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridSFtp::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+std::string HybridSFtp::getSyncDirectives() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SyncDirectives(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setSyncDirectives(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "syncDirectives");
+  this->ck().put_SyncDirectives(value.c_str());
+}
+double HybridSFtp::getXferByteCount() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_XferByteCount());
+}
+double HybridSFtp::getXferByteCount64() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_XferByteCount64());
+}
+std::string HybridSFtp::getServerIdentifier() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ServerIdentifier(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSFtp::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+std::string HybridSFtp::getSyncMustMatchDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SyncMustMatchDir(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setSyncMustMatchDir(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "syncMustMatchDir");
+  this->ck().put_SyncMustMatchDir(value.c_str());
+}
+std::string HybridSFtp::getSyncMustNotMatchDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SyncMustNotMatchDir(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setSyncMustNotMatchDir(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "syncMustNotMatchDir");
+  this->ck().put_SyncMustNotMatchDir(value.c_str());
+}
+bool HybridSFtp::getSyncCreateAllLocalDirs() {
+  this->beginCall();
+  return this->ck().get_SyncCreateAllLocalDirs();
+}
+void HybridSFtp::setSyncCreateAllLocalDirs(bool value) {
+  this->beginCall();
+  this->ck().put_SyncCreateAllLocalDirs(value);
+}
+double HybridSFtp::getLastStatusCode() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_LastStatusCode());
+}
+std::string HybridSFtp::getLastStatusMessage() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastStatusMessage(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSFtp::getUserAuthBanner() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UserAuthBanner(_s);
+  return rt::stdString(_s);
+}
+void HybridSFtp::setUserAuthBanner(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "userAuthBanner");
+  this->ck().put_UserAuthBanner(value.c_str());
+}
+bool HybridSFtp::getEnableSecrets() {
+  this->beginCall();
+  return this->ck().get_EnableSecrets();
+}
+void HybridSFtp::setEnableSecrets(bool value) {
+  this->beginCall();
+  this->ck().put_EnableSecrets(value);
+}
+
+// ---- Methods ----
+
+void HybridSFtp::authenticatePk(const std::string& username, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  authenticatePk_impl(username, privateKey);
+}
+void HybridSFtp::authenticatePk_impl(const std::string& username, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  rt::checkNoNul(username, "username");
+  if (!this->ck().AuthenticatePk(username.c_str(), rt::implOf<HybridSshKey>(privateKey, "privateKey").ck())) throw this->fail("authenticatePk");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::authenticatePkAsync(const std::string& username, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(privateKey);
+  return rt::runAsync<void>("SFtp.authenticatePkAsync", std::move(_parts), [_self, username, privateKey]() {
+    _self->authenticatePk_impl(username, privateKey);
+  });
+}
+
+void HybridSFtp::authenticatePw(const std::string& login, const std::string& password) {
+  this->beginCall();
+  authenticatePw_impl(login, password);
+}
+void HybridSFtp::authenticatePw_impl(const std::string& login, const std::string& password) {
+  rt::checkNoNul(login, "login");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().AuthenticatePw(login.c_str(), password.c_str())) throw this->fail("authenticatePw");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::authenticatePwAsync(const std::string& login, const std::string& password) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.authenticatePwAsync", std::move(_parts), [_self, login, password]() {
+    _self->authenticatePw_impl(login, password);
+  });
+}
+
+void HybridSFtp::authenticatePwPk(const std::string& username, const std::string& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  authenticatePwPk_impl(username, password, privateKey);
+}
+void HybridSFtp::authenticatePwPk_impl(const std::string& username, const std::string& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  rt::checkNoNul(username, "username");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().AuthenticatePwPk(username.c_str(), password.c_str(), rt::implOf<HybridSshKey>(privateKey, "privateKey").ck())) throw this->fail("authenticatePwPk");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::authenticatePwPkAsync(const std::string& username, const std::string& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(privateKey);
+  return rt::runAsync<void>("SFtp.authenticatePwPkAsync", std::move(_parts), [_self, username, password, privateKey]() {
+    _self->authenticatePwPk_impl(username, password, privateKey);
+  });
+}
+
+void HybridSFtp::clearCache() {
+  this->beginCall();
+  clearCache_impl();
+}
+void HybridSFtp::clearCache_impl() {
+  this->ck().ClearCache();
+}
+
+void HybridSFtp::clearSessionLog() {
+  this->beginCall();
+  clearSessionLog_impl();
+}
+void HybridSFtp::clearSessionLog_impl() {
+  this->ck().ClearSessionLog();
+}
+
+void HybridSFtp::closeHandle(const std::string& handle) {
+  this->beginCall();
+  closeHandle_impl(handle);
+}
+void HybridSFtp::closeHandle_impl(const std::string& handle) {
+  rt::checkNoNul(handle, "handle");
+  if (!this->ck().CloseHandle(handle.c_str())) throw this->fail("closeHandle");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::closeHandleAsync(const std::string& handle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.closeHandleAsync", std::move(_parts), [_self, handle]() {
+    _self->closeHandle_impl(handle);
+  });
+}
+
+void HybridSFtp::connect(const std::string& domainName, double port) {
+  this->beginCall();
+  connect_impl(domainName, port);
+}
+void HybridSFtp::connect_impl(const std::string& domainName, double port) {
+  rt::checkNoNul(domainName, "domainName");
+  if (!this->ck().Connect(domainName.c_str(), rt::toInt(port, "port"))) throw this->fail("connect");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::connectAsync(const std::string& domainName, double port) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.connectAsync", std::move(_parts), [_self, domainName, port]() {
+    _self->connect_impl(domainName, port);
+  });
+}
+
+void HybridSFtp::connectThroughSsh(const std::shared_ptr<HybridSshSpec>& sshConn, const std::string& hostname, double port) {
+  this->beginCall();
+  connectThroughSsh_impl(sshConn, hostname, port);
+}
+void HybridSFtp::connectThroughSsh_impl(const std::shared_ptr<HybridSshSpec>& sshConn, const std::string& hostname, double port) {
+  rt::checkNoNul(hostname, "hostname");
+  if (!this->ck().ConnectThroughSsh(rt::implOf<HybridSsh>(sshConn, "sshConn").ck(), hostname.c_str(), rt::toInt(port, "port"))) throw this->fail("connectThroughSsh");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::connectThroughSshAsync(const std::shared_ptr<HybridSshSpec>& sshConn, const std::string& hostname, double port) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sshConn);
+  return rt::runAsync<void>("SFtp.connectThroughSshAsync", std::move(_parts), [_self, sshConn, hostname, port]() {
+    _self->connectThroughSsh_impl(sshConn, hostname, port);
+  });
+}
+
+void HybridSFtp::copyFileAttr(const std::string& localFilename, const std::string& remoteFilename, bool isHandle) {
+  this->beginCall();
+  copyFileAttr_impl(localFilename, remoteFilename, isHandle);
+}
+void HybridSFtp::copyFileAttr_impl(const std::string& localFilename, const std::string& remoteFilename, bool isHandle) {
+  rt::checkNoNul(localFilename, "localFilename");
+  rt::checkNoNul(remoteFilename, "remoteFilename");
+  if (!this->ck().CopyFileAttr(localFilename.c_str(), remoteFilename.c_str(), isHandle)) throw this->fail("copyFileAttr");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::copyFileAttrAsync(const std::string& localFilename, const std::string& remoteFilename, bool isHandle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.copyFileAttrAsync", std::move(_parts), [_self, localFilename, remoteFilename, isHandle]() {
+    _self->copyFileAttr_impl(localFilename, remoteFilename, isHandle);
+  });
+}
+
+void HybridSFtp::createDir(const std::string& path) {
+  this->beginCall();
+  createDir_impl(path);
+}
+void HybridSFtp::createDir_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().CreateDir(path.c_str())) throw this->fail("createDir");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::createDirAsync(const std::string& path) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.createDirAsync", std::move(_parts), [_self, path]() {
+    _self->createDir_impl(path);
+  });
+}
+
+void HybridSFtp::disconnect() {
+  this->beginCall();
+  disconnect_impl();
+}
+void HybridSFtp::disconnect_impl() {
+  this->ck().Disconnect();
+}
+
+void HybridSFtp::downloadFile(const std::string& handle, const std::string& toFilename) {
+  this->beginCall();
+  downloadFile_impl(handle, toFilename);
+}
+void HybridSFtp::downloadFile_impl(const std::string& handle, const std::string& toFilename) {
+  rt::checkNoNul(handle, "handle");
+  rt::checkNoNul(toFilename, "toFilename");
+  if (!this->ck().DownloadFile(handle.c_str(), toFilename.c_str())) throw this->fail("downloadFile");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::downloadFileAsync(const std::string& handle, const std::string& toFilename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.downloadFileAsync", std::move(_parts), [_self, handle, toFilename]() {
+    _self->downloadFile_impl(handle, toFilename);
+  });
+}
+
+void HybridSFtp::downloadFileByName(const std::string& remoteFilePath, const std::string& localFilePath) {
+  this->beginCall();
+  downloadFileByName_impl(remoteFilePath, localFilePath);
+}
+void HybridSFtp::downloadFileByName_impl(const std::string& remoteFilePath, const std::string& localFilePath) {
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  rt::checkNoNul(localFilePath, "localFilePath");
+  if (!this->ck().DownloadFileByName(remoteFilePath.c_str(), localFilePath.c_str())) throw this->fail("downloadFileByName");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::downloadFileByNameAsync(const std::string& remoteFilePath, const std::string& localFilePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.downloadFileByNameAsync", std::move(_parts), [_self, remoteFilePath, localFilePath]() {
+    _self->downloadFileByName_impl(remoteFilePath, localFilePath);
+  });
+}
+
+bool HybridSFtp::eof(const std::string& handle) {
+  this->beginCall();
+  return eof_impl(handle);
+}
+bool HybridSFtp::eof_impl(const std::string& handle) {
+  rt::checkNoNul(handle, "handle");
+  return this->ck().Eof(handle.c_str());
+}
+
+std::string HybridSFtp::getFileCreateTimeStr(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  return getFileCreateTimeStr_impl(pathOrHandle, bFollowLinks, bIsHandle);
+}
+std::string HybridSFtp::getFileCreateTimeStr_impl(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  CkString _out;
+  if (!this->ck().GetFileCreateTimeStr(pathOrHandle.c_str(), bFollowLinks, bIsHandle, _out)) throw this->fail("getFileCreateTimeStr");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::getFileCreateTimeStrAsync(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.getFileCreateTimeStrAsync", std::move(_parts), [_self, pathOrHandle, bFollowLinks, bIsHandle]() {
+    return _self->getFileCreateTimeStr_impl(pathOrHandle, bFollowLinks, bIsHandle);
+  });
+}
+
+std::string HybridSFtp::getFileGroup(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  return getFileGroup_impl(pathOrHandle, bFollowLinks, bIsHandle);
+}
+std::string HybridSFtp::getFileGroup_impl(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  CkString _out;
+  if (!this->ck().GetFileGroup(pathOrHandle.c_str(), bFollowLinks, bIsHandle, _out)) throw this->fail("getFileGroup");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::getFileGroupAsync(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.getFileGroupAsync", std::move(_parts), [_self, pathOrHandle, bFollowLinks, bIsHandle]() {
+    return _self->getFileGroup_impl(pathOrHandle, bFollowLinks, bIsHandle);
+  });
+}
+
+std::string HybridSFtp::getFileLastAccessStr(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  return getFileLastAccessStr_impl(pathOrHandle, bFollowLinks, bIsHandle);
+}
+std::string HybridSFtp::getFileLastAccessStr_impl(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  CkString _out;
+  if (!this->ck().GetFileLastAccessStr(pathOrHandle.c_str(), bFollowLinks, bIsHandle, _out)) throw this->fail("getFileLastAccessStr");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::getFileLastAccessStrAsync(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.getFileLastAccessStrAsync", std::move(_parts), [_self, pathOrHandle, bFollowLinks, bIsHandle]() {
+    return _self->getFileLastAccessStr_impl(pathOrHandle, bFollowLinks, bIsHandle);
+  });
+}
+
+std::string HybridSFtp::getFileLastModifiedStr(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  return getFileLastModifiedStr_impl(pathOrHandle, bFollowLinks, bIsHandle);
+}
+std::string HybridSFtp::getFileLastModifiedStr_impl(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  CkString _out;
+  if (!this->ck().GetFileLastModifiedStr(pathOrHandle.c_str(), bFollowLinks, bIsHandle, _out)) throw this->fail("getFileLastModifiedStr");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::getFileLastModifiedStrAsync(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.getFileLastModifiedStrAsync", std::move(_parts), [_self, pathOrHandle, bFollowLinks, bIsHandle]() {
+    return _self->getFileLastModifiedStr_impl(pathOrHandle, bFollowLinks, bIsHandle);
+  });
+}
+
+std::string HybridSFtp::getFileOwner(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  return getFileOwner_impl(pathOrHandle, bFollowLinks, bIsHandle);
+}
+std::string HybridSFtp::getFileOwner_impl(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  CkString _out;
+  if (!this->ck().GetFileOwner(pathOrHandle.c_str(), bFollowLinks, bIsHandle, _out)) throw this->fail("getFileOwner");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::getFileOwnerAsync(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.getFileOwnerAsync", std::move(_parts), [_self, pathOrHandle, bFollowLinks, bIsHandle]() {
+    return _self->getFileOwner_impl(pathOrHandle, bFollowLinks, bIsHandle);
+  });
+}
+
+double HybridSFtp::getFilePermissions(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  return getFilePermissions_impl(pathOrHandle, bFollowLinks, bIsHandle);
+}
+double HybridSFtp::getFilePermissions_impl(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  return static_cast<double>(this->ck().GetFilePermissions(pathOrHandle.c_str(), bFollowLinks, bIsHandle));
+}
+std::shared_ptr<Promise<double>> HybridSFtp::getFilePermissionsAsync(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("SFtp.getFilePermissionsAsync", std::move(_parts), [_self, pathOrHandle, bFollowLinks, bIsHandle]() {
+    return _self->getFilePermissions_impl(pathOrHandle, bFollowLinks, bIsHandle);
+  });
+}
+
+double HybridSFtp::getFileSize32(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  return getFileSize32_impl(pathOrHandle, bFollowLinks, bIsHandle);
+}
+double HybridSFtp::getFileSize32_impl(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  return static_cast<double>(this->ck().GetFileSize32(pathOrHandle.c_str(), bFollowLinks, bIsHandle));
+}
+std::shared_ptr<Promise<double>> HybridSFtp::getFileSize32Async(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("SFtp.getFileSize32Async", std::move(_parts), [_self, pathOrHandle, bFollowLinks, bIsHandle]() {
+    return _self->getFileSize32_impl(pathOrHandle, bFollowLinks, bIsHandle);
+  });
+}
+
+double HybridSFtp::getFileSize64(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  return getFileSize64_impl(pathOrHandle, bFollowLinks, bIsHandle);
+}
+double HybridSFtp::getFileSize64_impl(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  return static_cast<double>(this->ck().GetFileSize64(pathOrHandle.c_str(), bFollowLinks, bIsHandle));
+}
+std::shared_ptr<Promise<double>> HybridSFtp::getFileSize64Async(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("SFtp.getFileSize64Async", std::move(_parts), [_self, pathOrHandle, bFollowLinks, bIsHandle]() {
+    return _self->getFileSize64_impl(pathOrHandle, bFollowLinks, bIsHandle);
+  });
+}
+
+std::string HybridSFtp::getFileSizeStr(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  return getFileSizeStr_impl(pathOrHandle, bFollowLinks, bIsHandle);
+}
+std::string HybridSFtp::getFileSizeStr_impl(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  CkString _out;
+  if (!this->ck().GetFileSizeStr(pathOrHandle.c_str(), bFollowLinks, bIsHandle, _out)) throw this->fail("getFileSizeStr");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::getFileSizeStrAsync(const std::string& pathOrHandle, bool bFollowLinks, bool bIsHandle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.getFileSizeStrAsync", std::move(_parts), [_self, pathOrHandle, bFollowLinks, bIsHandle]() {
+    return _self->getFileSizeStr_impl(pathOrHandle, bFollowLinks, bIsHandle);
+  });
+}
+
+void HybridSFtp::initializeSftp() {
+  this->beginCall();
+  initializeSftp_impl();
+}
+void HybridSFtp::initializeSftp_impl() {
+  if (!this->ck().InitializeSftp()) throw this->fail("initializeSftp");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::initializeSftpAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.initializeSftpAsync", std::move(_parts), [_self]() {
+    _self->initializeSftp_impl();
+  });
+}
+
+bool HybridSFtp::lastReadFailed(const std::string& handle) {
+  this->beginCall();
+  return lastReadFailed_impl(handle);
+}
+bool HybridSFtp::lastReadFailed_impl(const std::string& handle) {
+  rt::checkNoNul(handle, "handle");
+  return this->ck().LastReadFailed(handle.c_str());
+}
+
+double HybridSFtp::lastReadNumBytes(const std::string& handle) {
+  this->beginCall();
+  return lastReadNumBytes_impl(handle);
+}
+double HybridSFtp::lastReadNumBytes_impl(const std::string& handle) {
+  rt::checkNoNul(handle, "handle");
+  return static_cast<double>(this->ck().LastReadNumBytes(handle.c_str()));
+}
+
+std::string HybridSFtp::openDir(const std::string& path) {
+  this->beginCall();
+  return openDir_impl(path);
+}
+std::string HybridSFtp::openDir_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  CkString _out;
+  if (!this->ck().OpenDir(path.c_str(), _out)) throw this->fail("openDir");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::openDirAsync(const std::string& path) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.openDirAsync", std::move(_parts), [_self, path]() {
+    return _self->openDir_impl(path);
+  });
+}
+
+std::string HybridSFtp::openFile(const std::string& remotePath, const std::string& access, const std::string& createDisposition) {
+  this->beginCall();
+  return openFile_impl(remotePath, access, createDisposition);
+}
+std::string HybridSFtp::openFile_impl(const std::string& remotePath, const std::string& access, const std::string& createDisposition) {
+  rt::checkNoNul(remotePath, "remotePath");
+  rt::checkNoNul(access, "access");
+  rt::checkNoNul(createDisposition, "createDisposition");
+  CkString _out;
+  if (!this->ck().OpenFile(remotePath.c_str(), access.c_str(), createDisposition.c_str(), _out)) throw this->fail("openFile");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::openFileAsync(const std::string& remotePath, const std::string& access, const std::string& createDisposition) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.openFileAsync", std::move(_parts), [_self, remotePath, access, createDisposition]() {
+    return _self->openFile_impl(remotePath, access, createDisposition);
+  });
+}
+
+std::string HybridSFtp::readFileText(const std::string& handle, double numBytes, const std::string& charset) {
+  this->beginCall();
+  return readFileText_impl(handle, numBytes, charset);
+}
+std::string HybridSFtp::readFileText_impl(const std::string& handle, double numBytes, const std::string& charset) {
+  rt::checkNoNul(handle, "handle");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().ReadFileText(handle.c_str(), rt::toInt(numBytes, "numBytes"), charset.c_str(), _out)) throw this->fail("readFileText");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::readFileTextAsync(const std::string& handle, double numBytes, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.readFileTextAsync", std::move(_parts), [_self, handle, numBytes, charset]() {
+    return _self->readFileText_impl(handle, numBytes, charset);
+  });
+}
+
+std::string HybridSFtp::readFileText32(const std::string& handle, double offset, double numBytes, const std::string& charset) {
+  this->beginCall();
+  return readFileText32_impl(handle, offset, numBytes, charset);
+}
+std::string HybridSFtp::readFileText32_impl(const std::string& handle, double offset, double numBytes, const std::string& charset) {
+  rt::checkNoNul(handle, "handle");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().ReadFileText32(handle.c_str(), rt::toInt(offset, "offset"), rt::toInt(numBytes, "numBytes"), charset.c_str(), _out)) throw this->fail("readFileText32");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::readFileText32Async(const std::string& handle, double offset, double numBytes, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.readFileText32Async", std::move(_parts), [_self, handle, offset, numBytes, charset]() {
+    return _self->readFileText32_impl(handle, offset, numBytes, charset);
+  });
+}
+
+std::string HybridSFtp::readFileText64(const std::string& handle, double offset, double numBytes, const std::string& charset) {
+  this->beginCall();
+  return readFileText64_impl(handle, offset, numBytes, charset);
+}
+std::string HybridSFtp::readFileText64_impl(const std::string& handle, double offset, double numBytes, const std::string& charset) {
+  rt::checkNoNul(handle, "handle");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().ReadFileText64(handle.c_str(), rt::toInt64(offset, "offset"), rt::toInt(numBytes, "numBytes"), charset.c_str(), _out)) throw this->fail("readFileText64");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::readFileText64Async(const std::string& handle, double offset, double numBytes, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.readFileText64Async", std::move(_parts), [_self, handle, offset, numBytes, charset]() {
+    return _self->readFileText64_impl(handle, offset, numBytes, charset);
+  });
+}
+
+std::string HybridSFtp::readFileText64s(const std::string& handle, const std::string& offset, double numBytes, const std::string& charset) {
+  this->beginCall();
+  return readFileText64s_impl(handle, offset, numBytes, charset);
+}
+std::string HybridSFtp::readFileText64s_impl(const std::string& handle, const std::string& offset, double numBytes, const std::string& charset) {
+  rt::checkNoNul(handle, "handle");
+  rt::checkNoNul(offset, "offset");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().ReadFileText64s(handle.c_str(), offset.c_str(), rt::toInt(numBytes, "numBytes"), charset.c_str(), _out)) throw this->fail("readFileText64s");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::readFileText64sAsync(const std::string& handle, const std::string& offset, double numBytes, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.readFileText64sAsync", std::move(_parts), [_self, handle, offset, numBytes, charset]() {
+    return _self->readFileText64s_impl(handle, offset, numBytes, charset);
+  });
+}
+
+std::string HybridSFtp::realPath(const std::string& originalPath, const std::string& composePath) {
+  this->beginCall();
+  return realPath_impl(originalPath, composePath);
+}
+std::string HybridSFtp::realPath_impl(const std::string& originalPath, const std::string& composePath) {
+  rt::checkNoNul(originalPath, "originalPath");
+  rt::checkNoNul(composePath, "composePath");
+  CkString _out;
+  if (!this->ck().RealPath(originalPath.c_str(), composePath.c_str(), _out)) throw this->fail("realPath");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::realPathAsync(const std::string& originalPath, const std::string& composePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.realPathAsync", std::move(_parts), [_self, originalPath, composePath]() {
+    return _self->realPath_impl(originalPath, composePath);
+  });
+}
+
+void HybridSFtp::removeDir(const std::string& path) {
+  this->beginCall();
+  removeDir_impl(path);
+}
+void HybridSFtp::removeDir_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().RemoveDir(path.c_str())) throw this->fail("removeDir");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::removeDirAsync(const std::string& path) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.removeDirAsync", std::move(_parts), [_self, path]() {
+    _self->removeDir_impl(path);
+  });
+}
+
+void HybridSFtp::removeFile(const std::string& filename) {
+  this->beginCall();
+  removeFile_impl(filename);
+}
+void HybridSFtp::removeFile_impl(const std::string& filename) {
+  rt::checkNoNul(filename, "filename");
+  if (!this->ck().RemoveFile(filename.c_str())) throw this->fail("removeFile");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::removeFileAsync(const std::string& filename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.removeFileAsync", std::move(_parts), [_self, filename]() {
+    _self->removeFile_impl(filename);
+  });
+}
+
+void HybridSFtp::renameFileOrDir(const std::string& oldPath, const std::string& newPath) {
+  this->beginCall();
+  renameFileOrDir_impl(oldPath, newPath);
+}
+void HybridSFtp::renameFileOrDir_impl(const std::string& oldPath, const std::string& newPath) {
+  rt::checkNoNul(oldPath, "oldPath");
+  rt::checkNoNul(newPath, "newPath");
+  if (!this->ck().RenameFileOrDir(oldPath.c_str(), newPath.c_str())) throw this->fail("renameFileOrDir");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::renameFileOrDirAsync(const std::string& oldPath, const std::string& newPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.renameFileOrDirAsync", std::move(_parts), [_self, oldPath, newPath]() {
+    _self->renameFileOrDir_impl(oldPath, newPath);
+  });
+}
+
+void HybridSFtp::resumeDownloadFileByName(const std::string& remoteFilePath, const std::string& localFilePath) {
+  this->beginCall();
+  resumeDownloadFileByName_impl(remoteFilePath, localFilePath);
+}
+void HybridSFtp::resumeDownloadFileByName_impl(const std::string& remoteFilePath, const std::string& localFilePath) {
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  rt::checkNoNul(localFilePath, "localFilePath");
+  if (!this->ck().ResumeDownloadFileByName(remoteFilePath.c_str(), localFilePath.c_str())) throw this->fail("resumeDownloadFileByName");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::resumeDownloadFileByNameAsync(const std::string& remoteFilePath, const std::string& localFilePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.resumeDownloadFileByNameAsync", std::move(_parts), [_self, remoteFilePath, localFilePath]() {
+    _self->resumeDownloadFileByName_impl(remoteFilePath, localFilePath);
+  });
+}
+
+void HybridSFtp::resumeUploadFileByName(const std::string& remoteFilePath, const std::string& localFilePath) {
+  this->beginCall();
+  resumeUploadFileByName_impl(remoteFilePath, localFilePath);
+}
+void HybridSFtp::resumeUploadFileByName_impl(const std::string& remoteFilePath, const std::string& localFilePath) {
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  rt::checkNoNul(localFilePath, "localFilePath");
+  if (!this->ck().ResumeUploadFileByName(remoteFilePath.c_str(), localFilePath.c_str())) throw this->fail("resumeUploadFileByName");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::resumeUploadFileByNameAsync(const std::string& remoteFilePath, const std::string& localFilePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.resumeUploadFileByNameAsync", std::move(_parts), [_self, remoteFilePath, localFilePath]() {
+    _self->resumeUploadFileByName_impl(remoteFilePath, localFilePath);
+  });
+}
+
+void HybridSFtp::setCreateDt(const std::string& pathOrHandle, bool isHandle, const std::shared_ptr<HybridCkDateTimeSpec>& createDateTime) {
+  this->beginCall();
+  setCreateDt_impl(pathOrHandle, isHandle, createDateTime);
+}
+void HybridSFtp::setCreateDt_impl(const std::string& pathOrHandle, bool isHandle, const std::shared_ptr<HybridCkDateTimeSpec>& createDateTime) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  if (!this->ck().SetCreateDt(pathOrHandle.c_str(), isHandle, rt::implOf<HybridCkDateTime>(createDateTime, "createDateTime").ck())) throw this->fail("setCreateDt");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::setCreateDtAsync(const std::string& pathOrHandle, bool isHandle, const std::shared_ptr<HybridCkDateTimeSpec>& createDateTime) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(createDateTime);
+  return rt::runAsync<void>("SFtp.setCreateDtAsync", std::move(_parts), [_self, pathOrHandle, isHandle, createDateTime]() {
+    _self->setCreateDt_impl(pathOrHandle, isHandle, createDateTime);
+  });
+}
+
+void HybridSFtp::setCreateTimeStr(const std::string& pathOrHandle, bool bIsHandle, const std::string& dateTimeStr) {
+  this->beginCall();
+  setCreateTimeStr_impl(pathOrHandle, bIsHandle, dateTimeStr);
+}
+void HybridSFtp::setCreateTimeStr_impl(const std::string& pathOrHandle, bool bIsHandle, const std::string& dateTimeStr) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  rt::checkNoNul(dateTimeStr, "dateTimeStr");
+  if (!this->ck().SetCreateTimeStr(pathOrHandle.c_str(), bIsHandle, dateTimeStr.c_str())) throw this->fail("setCreateTimeStr");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::setCreateTimeStrAsync(const std::string& pathOrHandle, bool bIsHandle, const std::string& dateTimeStr) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.setCreateTimeStrAsync", std::move(_parts), [_self, pathOrHandle, bIsHandle, dateTimeStr]() {
+    _self->setCreateTimeStr_impl(pathOrHandle, bIsHandle, dateTimeStr);
+  });
+}
+
+void HybridSFtp::setLastAccessDt(const std::string& pathOrHandle, bool isHandle, const std::shared_ptr<HybridCkDateTimeSpec>& accessDateTime) {
+  this->beginCall();
+  setLastAccessDt_impl(pathOrHandle, isHandle, accessDateTime);
+}
+void HybridSFtp::setLastAccessDt_impl(const std::string& pathOrHandle, bool isHandle, const std::shared_ptr<HybridCkDateTimeSpec>& accessDateTime) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  if (!this->ck().SetLastAccessDt(pathOrHandle.c_str(), isHandle, rt::implOf<HybridCkDateTime>(accessDateTime, "accessDateTime").ck())) throw this->fail("setLastAccessDt");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::setLastAccessDtAsync(const std::string& pathOrHandle, bool isHandle, const std::shared_ptr<HybridCkDateTimeSpec>& accessDateTime) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(accessDateTime);
+  return rt::runAsync<void>("SFtp.setLastAccessDtAsync", std::move(_parts), [_self, pathOrHandle, isHandle, accessDateTime]() {
+    _self->setLastAccessDt_impl(pathOrHandle, isHandle, accessDateTime);
+  });
+}
+
+void HybridSFtp::setLastAccessTimeStr(const std::string& pathOrHandle, bool bIsHandle, const std::string& dateTimeStr) {
+  this->beginCall();
+  setLastAccessTimeStr_impl(pathOrHandle, bIsHandle, dateTimeStr);
+}
+void HybridSFtp::setLastAccessTimeStr_impl(const std::string& pathOrHandle, bool bIsHandle, const std::string& dateTimeStr) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  rt::checkNoNul(dateTimeStr, "dateTimeStr");
+  if (!this->ck().SetLastAccessTimeStr(pathOrHandle.c_str(), bIsHandle, dateTimeStr.c_str())) throw this->fail("setLastAccessTimeStr");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::setLastAccessTimeStrAsync(const std::string& pathOrHandle, bool bIsHandle, const std::string& dateTimeStr) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.setLastAccessTimeStrAsync", std::move(_parts), [_self, pathOrHandle, bIsHandle, dateTimeStr]() {
+    _self->setLastAccessTimeStr_impl(pathOrHandle, bIsHandle, dateTimeStr);
+  });
+}
+
+void HybridSFtp::setLastModifiedDt(const std::string& pathOrHandle, bool isHandle, const std::shared_ptr<HybridCkDateTimeSpec>& modifiedDateTime) {
+  this->beginCall();
+  setLastModifiedDt_impl(pathOrHandle, isHandle, modifiedDateTime);
+}
+void HybridSFtp::setLastModifiedDt_impl(const std::string& pathOrHandle, bool isHandle, const std::shared_ptr<HybridCkDateTimeSpec>& modifiedDateTime) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  if (!this->ck().SetLastModifiedDt(pathOrHandle.c_str(), isHandle, rt::implOf<HybridCkDateTime>(modifiedDateTime, "modifiedDateTime").ck())) throw this->fail("setLastModifiedDt");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::setLastModifiedDtAsync(const std::string& pathOrHandle, bool isHandle, const std::shared_ptr<HybridCkDateTimeSpec>& modifiedDateTime) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(modifiedDateTime);
+  return rt::runAsync<void>("SFtp.setLastModifiedDtAsync", std::move(_parts), [_self, pathOrHandle, isHandle, modifiedDateTime]() {
+    _self->setLastModifiedDt_impl(pathOrHandle, isHandle, modifiedDateTime);
+  });
+}
+
+void HybridSFtp::setLastModifiedTimeStr(const std::string& pathOrHandle, bool bIsHandle, const std::string& dateTimeStr) {
+  this->beginCall();
+  setLastModifiedTimeStr_impl(pathOrHandle, bIsHandle, dateTimeStr);
+}
+void HybridSFtp::setLastModifiedTimeStr_impl(const std::string& pathOrHandle, bool bIsHandle, const std::string& dateTimeStr) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  rt::checkNoNul(dateTimeStr, "dateTimeStr");
+  if (!this->ck().SetLastModifiedTimeStr(pathOrHandle.c_str(), bIsHandle, dateTimeStr.c_str())) throw this->fail("setLastModifiedTimeStr");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::setLastModifiedTimeStrAsync(const std::string& pathOrHandle, bool bIsHandle, const std::string& dateTimeStr) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.setLastModifiedTimeStrAsync", std::move(_parts), [_self, pathOrHandle, bIsHandle, dateTimeStr]() {
+    _self->setLastModifiedTimeStr_impl(pathOrHandle, bIsHandle, dateTimeStr);
+  });
+}
+
+void HybridSFtp::setOwnerAndGroup(const std::string& pathOrHandle, bool isHandle, const std::string& owner, const std::string& group) {
+  this->beginCall();
+  setOwnerAndGroup_impl(pathOrHandle, isHandle, owner, group);
+}
+void HybridSFtp::setOwnerAndGroup_impl(const std::string& pathOrHandle, bool isHandle, const std::string& owner, const std::string& group) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  rt::checkNoNul(owner, "owner");
+  rt::checkNoNul(group, "group");
+  if (!this->ck().SetOwnerAndGroup(pathOrHandle.c_str(), isHandle, owner.c_str(), group.c_str())) throw this->fail("setOwnerAndGroup");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::setOwnerAndGroupAsync(const std::string& pathOrHandle, bool isHandle, const std::string& owner, const std::string& group) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.setOwnerAndGroupAsync", std::move(_parts), [_self, pathOrHandle, isHandle, owner, group]() {
+    _self->setOwnerAndGroup_impl(pathOrHandle, isHandle, owner, group);
+  });
+}
+
+void HybridSFtp::setPermissions(const std::string& pathOrHandle, bool isHandle, double permissions) {
+  this->beginCall();
+  setPermissions_impl(pathOrHandle, isHandle, permissions);
+}
+void HybridSFtp::setPermissions_impl(const std::string& pathOrHandle, bool isHandle, double permissions) {
+  rt::checkNoNul(pathOrHandle, "pathOrHandle");
+  if (!this->ck().SetPermissions(pathOrHandle.c_str(), isHandle, rt::toInt(permissions, "permissions"))) throw this->fail("setPermissions");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::setPermissionsAsync(const std::string& pathOrHandle, bool isHandle, double permissions) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.setPermissionsAsync", std::move(_parts), [_self, pathOrHandle, isHandle, permissions]() {
+    _self->setPermissions_impl(pathOrHandle, isHandle, permissions);
+  });
+}
+
+void HybridSFtp::syncTreeDownload(const std::string& remoteRoot, const std::string& localRoot, double mode, bool recurse) {
+  this->beginCall();
+  syncTreeDownload_impl(remoteRoot, localRoot, mode, recurse);
+}
+void HybridSFtp::syncTreeDownload_impl(const std::string& remoteRoot, const std::string& localRoot, double mode, bool recurse) {
+  rt::checkNoNul(remoteRoot, "remoteRoot");
+  rt::checkNoNul(localRoot, "localRoot");
+  if (!this->ck().SyncTreeDownload(remoteRoot.c_str(), localRoot.c_str(), rt::toInt(mode, "mode"), recurse)) throw this->fail("syncTreeDownload");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::syncTreeDownloadAsync(const std::string& remoteRoot, const std::string& localRoot, double mode, bool recurse) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.syncTreeDownloadAsync", std::move(_parts), [_self, remoteRoot, localRoot, mode, recurse]() {
+    _self->syncTreeDownload_impl(remoteRoot, localRoot, mode, recurse);
+  });
+}
+
+void HybridSFtp::syncTreeUpload(const std::string& localBaseDir, const std::string& remoteBaseDir, double mode, bool bRecurse) {
+  this->beginCall();
+  syncTreeUpload_impl(localBaseDir, remoteBaseDir, mode, bRecurse);
+}
+void HybridSFtp::syncTreeUpload_impl(const std::string& localBaseDir, const std::string& remoteBaseDir, double mode, bool bRecurse) {
+  rt::checkNoNul(localBaseDir, "localBaseDir");
+  rt::checkNoNul(remoteBaseDir, "remoteBaseDir");
+  if (!this->ck().SyncTreeUpload(localBaseDir.c_str(), remoteBaseDir.c_str(), rt::toInt(mode, "mode"), bRecurse)) throw this->fail("syncTreeUpload");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::syncTreeUploadAsync(const std::string& localBaseDir, const std::string& remoteBaseDir, double mode, bool bRecurse) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.syncTreeUploadAsync", std::move(_parts), [_self, localBaseDir, remoteBaseDir, mode, bRecurse]() {
+    _self->syncTreeUpload_impl(localBaseDir, remoteBaseDir, mode, bRecurse);
+  });
+}
+
+void HybridSFtp::uploadFile(const std::string& handle, const std::string& fromLocalFilePath) {
+  this->beginCall();
+  uploadFile_impl(handle, fromLocalFilePath);
+}
+void HybridSFtp::uploadFile_impl(const std::string& handle, const std::string& fromLocalFilePath) {
+  rt::checkNoNul(handle, "handle");
+  rt::checkNoNul(fromLocalFilePath, "fromLocalFilePath");
+  if (!this->ck().UploadFile(handle.c_str(), fromLocalFilePath.c_str())) throw this->fail("uploadFile");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::uploadFileAsync(const std::string& handle, const std::string& fromLocalFilePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.uploadFileAsync", std::move(_parts), [_self, handle, fromLocalFilePath]() {
+    _self->uploadFile_impl(handle, fromLocalFilePath);
+  });
+}
+
+void HybridSFtp::uploadFileByName(const std::string& remoteFilePath, const std::string& localFilePath) {
+  this->beginCall();
+  uploadFileByName_impl(remoteFilePath, localFilePath);
+}
+void HybridSFtp::uploadFileByName_impl(const std::string& remoteFilePath, const std::string& localFilePath) {
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  rt::checkNoNul(localFilePath, "localFilePath");
+  if (!this->ck().UploadFileByName(remoteFilePath.c_str(), localFilePath.c_str())) throw this->fail("uploadFileByName");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::uploadFileByNameAsync(const std::string& remoteFilePath, const std::string& localFilePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.uploadFileByNameAsync", std::move(_parts), [_self, remoteFilePath, localFilePath]() {
+    _self->uploadFileByName_impl(remoteFilePath, localFilePath);
+  });
+}
+
+void HybridSFtp::writeFileText(const std::string& handle, const std::string& charset, const std::string& textData) {
+  this->beginCall();
+  writeFileText_impl(handle, charset, textData);
+}
+void HybridSFtp::writeFileText_impl(const std::string& handle, const std::string& charset, const std::string& textData) {
+  rt::checkNoNul(handle, "handle");
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(textData, "textData");
+  if (!this->ck().WriteFileText(handle.c_str(), charset.c_str(), textData.c_str())) throw this->fail("writeFileText");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::writeFileTextAsync(const std::string& handle, const std::string& charset, const std::string& textData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.writeFileTextAsync", std::move(_parts), [_self, handle, charset, textData]() {
+    _self->writeFileText_impl(handle, charset, textData);
+  });
+}
+
+void HybridSFtp::writeFileText32(const std::string& handle, double offset32, const std::string& charset, const std::string& textData) {
+  this->beginCall();
+  writeFileText32_impl(handle, offset32, charset, textData);
+}
+void HybridSFtp::writeFileText32_impl(const std::string& handle, double offset32, const std::string& charset, const std::string& textData) {
+  rt::checkNoNul(handle, "handle");
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(textData, "textData");
+  if (!this->ck().WriteFileText32(handle.c_str(), rt::toInt(offset32, "offset32"), charset.c_str(), textData.c_str())) throw this->fail("writeFileText32");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::writeFileText32Async(const std::string& handle, double offset32, const std::string& charset, const std::string& textData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.writeFileText32Async", std::move(_parts), [_self, handle, offset32, charset, textData]() {
+    _self->writeFileText32_impl(handle, offset32, charset, textData);
+  });
+}
+
+void HybridSFtp::writeFileText64(const std::string& handle, double offset64, const std::string& charset, const std::string& textData) {
+  this->beginCall();
+  writeFileText64_impl(handle, offset64, charset, textData);
+}
+void HybridSFtp::writeFileText64_impl(const std::string& handle, double offset64, const std::string& charset, const std::string& textData) {
+  rt::checkNoNul(handle, "handle");
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(textData, "textData");
+  if (!this->ck().WriteFileText64(handle.c_str(), rt::toInt64(offset64, "offset64"), charset.c_str(), textData.c_str())) throw this->fail("writeFileText64");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::writeFileText64Async(const std::string& handle, double offset64, const std::string& charset, const std::string& textData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.writeFileText64Async", std::move(_parts), [_self, handle, offset64, charset, textData]() {
+    _self->writeFileText64_impl(handle, offset64, charset, textData);
+  });
+}
+
+void HybridSFtp::writeFileText64s(const std::string& handle, const std::string& offset64, const std::string& charset, const std::string& textData) {
+  this->beginCall();
+  writeFileText64s_impl(handle, offset64, charset, textData);
+}
+void HybridSFtp::writeFileText64s_impl(const std::string& handle, const std::string& offset64, const std::string& charset, const std::string& textData) {
+  rt::checkNoNul(handle, "handle");
+  rt::checkNoNul(offset64, "offset64");
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(textData, "textData");
+  if (!this->ck().WriteFileText64s(handle.c_str(), offset64.c_str(), charset.c_str(), textData.c_str())) throw this->fail("writeFileText64s");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::writeFileText64sAsync(const std::string& handle, const std::string& offset64, const std::string& charset, const std::string& textData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.writeFileText64sAsync", std::move(_parts), [_self, handle, offset64, charset, textData]() {
+    _self->writeFileText64s_impl(handle, offset64, charset, textData);
+  });
+}
+
+void HybridSFtp::uploadSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& remoteFilePath, const std::string& charset, bool includeBom) {
+  this->beginCall();
+  uploadSb_impl(sb, remoteFilePath, charset, includeBom);
+}
+void HybridSFtp::uploadSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& remoteFilePath, const std::string& charset, bool includeBom) {
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().UploadSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck(), remoteFilePath.c_str(), charset.c_str(), includeBom)) throw this->fail("uploadSb");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::uploadSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& remoteFilePath, const std::string& charset, bool includeBom) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<void>("SFtp.uploadSbAsync", std::move(_parts), [_self, sb, remoteFilePath, charset, includeBom]() {
+    _self->uploadSb_impl(sb, remoteFilePath, charset, includeBom);
+  });
+}
+
+void HybridSFtp::uploadBd(const std::shared_ptr<HybridBinDataSpec>& binData, const std::string& remoteFilePath) {
+  this->beginCall();
+  uploadBd_impl(binData, remoteFilePath);
+}
+void HybridSFtp::uploadBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData, const std::string& remoteFilePath) {
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  if (!this->ck().UploadBd(rt::implOf<HybridBinData>(binData, "binData").ck(), remoteFilePath.c_str())) throw this->fail("uploadBd");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::uploadBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData, const std::string& remoteFilePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  return rt::runAsync<void>("SFtp.uploadBdAsync", std::move(_parts), [_self, binData, remoteFilePath]() {
+    _self->uploadBd_impl(binData, remoteFilePath);
+  });
+}
+
+void HybridSFtp::downloadBd(const std::string& remoteFilePath, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  downloadBd_impl(remoteFilePath, binData);
+}
+void HybridSFtp::downloadBd_impl(const std::string& remoteFilePath, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  rt::checkNoNul(remoteFilePath, "remoteFilePath");
+  if (!this->ck().DownloadBd(remoteFilePath.c_str(), rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("downloadBd");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::downloadBdAsync(const std::string& remoteFilePath, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  return rt::runAsync<void>("SFtp.downloadBdAsync", std::move(_parts), [_self, remoteFilePath, binData]() {
+    _self->downloadBd_impl(remoteFilePath, binData);
+  });
+}
+
+void HybridSFtp::downloadSb(const std::string& remoteFilePath, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  downloadSb_impl(remoteFilePath, charset, sb);
+}
+void HybridSFtp::downloadSb_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().DownloadSb(remoteFilePath.c_str(), charset.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("downloadSb");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::downloadSbAsync(const std::string& remoteFilePath, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<void>("SFtp.downloadSbAsync", std::move(_parts), [_self, remoteFilePath, charset, sb]() {
+    _self->downloadSb_impl(remoteFilePath, charset, sb);
+  });
+}
+
+void HybridSFtp::sendIgnore() {
+  this->beginCall();
+  sendIgnore_impl();
+}
+void HybridSFtp::sendIgnore_impl() {
+  if (!this->ck().SendIgnore()) throw this->fail("sendIgnore");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::sendIgnoreAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.sendIgnoreAsync", std::move(_parts), [_self]() {
+    _self->sendIgnore_impl();
+  });
+}
+
+double HybridSFtp::fileExists(const std::string& remotePath, bool followLinks) {
+  this->beginCall();
+  return fileExists_impl(remotePath, followLinks);
+}
+double HybridSFtp::fileExists_impl(const std::string& remotePath, bool followLinks) {
+  rt::checkNoNul(remotePath, "remotePath");
+  return static_cast<double>(this->ck().FileExists(remotePath.c_str(), followLinks));
+}
+std::shared_ptr<Promise<double>> HybridSFtp::fileExistsAsync(const std::string& remotePath, bool followLinks) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("SFtp.fileExistsAsync", std::move(_parts), [_self, remotePath, followLinks]() {
+    return _self->fileExists_impl(remotePath, followLinks);
+  });
+}
+
+void HybridSFtp::authenticateSecPw(const std::shared_ptr<HybridSecureStringSpec>& login, const std::shared_ptr<HybridSecureStringSpec>& password) {
+  this->beginCall();
+  authenticateSecPw_impl(login, password);
+}
+void HybridSFtp::authenticateSecPw_impl(const std::shared_ptr<HybridSecureStringSpec>& login, const std::shared_ptr<HybridSecureStringSpec>& password) {
+  if (!this->ck().AuthenticateSecPw(rt::implOf<HybridSecureString>(login, "login").ck(), rt::implOf<HybridSecureString>(password, "password").ck())) throw this->fail("authenticateSecPw");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::authenticateSecPwAsync(const std::shared_ptr<HybridSecureStringSpec>& login, const std::shared_ptr<HybridSecureStringSpec>& password) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(login);
+  _parts.push_back(password);
+  return rt::runAsync<void>("SFtp.authenticateSecPwAsync", std::move(_parts), [_self, login, password]() {
+    _self->authenticateSecPw_impl(login, password);
+  });
+}
+
+void HybridSFtp::authenticateSecPwPk(const std::shared_ptr<HybridSecureStringSpec>& username, const std::shared_ptr<HybridSecureStringSpec>& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  authenticateSecPwPk_impl(username, password, privateKey);
+}
+void HybridSFtp::authenticateSecPwPk_impl(const std::shared_ptr<HybridSecureStringSpec>& username, const std::shared_ptr<HybridSecureStringSpec>& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  if (!this->ck().AuthenticateSecPwPk(rt::implOf<HybridSecureString>(username, "username").ck(), rt::implOf<HybridSecureString>(password, "password").ck(), rt::implOf<HybridSshKey>(privateKey, "privateKey").ck())) throw this->fail("authenticateSecPwPk");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::authenticateSecPwPkAsync(const std::shared_ptr<HybridSecureStringSpec>& username, const std::shared_ptr<HybridSecureStringSpec>& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(username);
+  _parts.push_back(password);
+  _parts.push_back(privateKey);
+  return rt::runAsync<void>("SFtp.authenticateSecPwPkAsync", std::move(_parts), [_self, username, password, privateKey]() {
+    _self->authenticateSecPwPk_impl(username, password, privateKey);
+  });
+}
+
+void HybridSFtp::symLink(const std::string& oldPath, const std::string& newPath) {
+  this->beginCall();
+  symLink_impl(oldPath, newPath);
+}
+void HybridSFtp::symLink_impl(const std::string& oldPath, const std::string& newPath) {
+  rt::checkNoNul(oldPath, "oldPath");
+  rt::checkNoNul(newPath, "newPath");
+  if (!this->ck().SymLink(oldPath.c_str(), newPath.c_str())) throw this->fail("symLink");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::symLinkAsync(const std::string& oldPath, const std::string& newPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.symLinkAsync", std::move(_parts), [_self, oldPath, newPath]() {
+    _self->symLink_impl(oldPath, newPath);
+  });
+}
+
+void HybridSFtp::hardLink(const std::string& oldPath, const std::string& newPath) {
+  this->beginCall();
+  hardLink_impl(oldPath, newPath);
+}
+void HybridSFtp::hardLink_impl(const std::string& oldPath, const std::string& newPath) {
+  rt::checkNoNul(oldPath, "oldPath");
+  rt::checkNoNul(newPath, "newPath");
+  if (!this->ck().HardLink(oldPath.c_str(), newPath.c_str())) throw this->fail("hardLink");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::hardLinkAsync(const std::string& oldPath, const std::string& newPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.hardLinkAsync", std::move(_parts), [_self, oldPath, newPath]() {
+    _self->hardLink_impl(oldPath, newPath);
+  });
+}
+
+void HybridSFtp::fsync(const std::string& handle) {
+  this->beginCall();
+  fsync_impl(handle);
+}
+void HybridSFtp::fsync_impl(const std::string& handle) {
+  rt::checkNoNul(handle, "handle");
+  if (!this->ck().Fsync(handle.c_str())) throw this->fail("fsync");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::fsyncAsync(const std::string& handle) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SFtp.fsyncAsync", std::move(_parts), [_self, handle]() {
+    _self->fsync_impl(handle);
+  });
+}
+
+std::string HybridSFtp::readLink(const std::string& path) {
+  this->beginCall();
+  return readLink_impl(path);
+}
+std::string HybridSFtp::readLink_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  CkString _out;
+  if (!this->ck().ReadLink(path.c_str(), _out)) throw this->fail("readLink");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::readLinkAsync(const std::string& path) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.readLinkAsync", std::move(_parts), [_self, path]() {
+    return _self->readLink_impl(path);
+  });
+}
+
+void HybridSFtp::writeFileBd(const std::string& handle, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  writeFileBd_impl(handle, bd);
+}
+void HybridSFtp::writeFileBd_impl(const std::string& handle, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(handle, "handle");
+  if (!this->ck().WriteFileBd(handle.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("writeFileBd");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::writeFileBdAsync(const std::string& handle, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("SFtp.writeFileBdAsync", std::move(_parts), [_self, handle, bd]() {
+    _self->writeFileBd_impl(handle, bd);
+  });
+}
+
+void HybridSFtp::readFileBd(const std::string& handle, double numBytes, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  readFileBd_impl(handle, numBytes, bd);
+}
+void HybridSFtp::readFileBd_impl(const std::string& handle, double numBytes, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(handle, "handle");
+  if (!this->ck().ReadFileBd(handle.c_str(), rt::toInt(numBytes, "numBytes"), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("readFileBd");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::readFileBdAsync(const std::string& handle, double numBytes, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("SFtp.readFileBdAsync", std::move(_parts), [_self, handle, numBytes, bd]() {
+    _self->readFileBd_impl(handle, numBytes, bd);
+  });
+}
+
+std::string HybridSFtp::startKeyboardAuth(const std::string& login) {
+  this->beginCall();
+  return startKeyboardAuth_impl(login);
+}
+std::string HybridSFtp::startKeyboardAuth_impl(const std::string& login) {
+  rt::checkNoNul(login, "login");
+  CkString _out;
+  if (!this->ck().StartKeyboardAuth(login.c_str(), _out)) throw this->fail("startKeyboardAuth");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::startKeyboardAuthAsync(const std::string& login) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.startKeyboardAuthAsync", std::move(_parts), [_self, login]() {
+    return _self->startKeyboardAuth_impl(login);
+  });
+}
+
+std::string HybridSFtp::continueKeyboardAuth(const std::string& response) {
+  this->beginCall();
+  return continueKeyboardAuth_impl(response);
+}
+std::string HybridSFtp::continueKeyboardAuth_impl(const std::string& response) {
+  rt::checkNoNul(response, "response");
+  CkString _out;
+  if (!this->ck().ContinueKeyboardAuth(response.c_str(), _out)) throw this->fail("continueKeyboardAuth");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSFtp::continueKeyboardAuthAsync(const std::string& response) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SFtp.continueKeyboardAuthAsync", std::move(_parts), [_self, response]() {
+    return _self->continueKeyboardAuth_impl(response);
+  });
+}
+
+std::string HybridSFtp::getHostKeyFP(const std::string& hashAlg, bool includeKeyType, bool includeHashName) {
+  this->beginCall();
+  return getHostKeyFP_impl(hashAlg, includeKeyType, includeHashName);
+}
+std::string HybridSFtp::getHostKeyFP_impl(const std::string& hashAlg, bool includeKeyType, bool includeHashName) {
+  rt::checkNoNul(hashAlg, "hashAlg");
+  CkString _out;
+  if (!this->ck().GetHostKeyFP(hashAlg.c_str(), includeKeyType, includeHashName, _out)) throw this->fail("getHostKeyFP");
+  return rt::stdString(_out);
+}
+
+void HybridSFtp::setAllowedAlgorithms(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  setAllowedAlgorithms_impl(json);
+}
+void HybridSFtp::setAllowedAlgorithms_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().SetAllowedAlgorithms(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("setAllowedAlgorithms");
+}
+
+void HybridSFtp::getSyncedFiles(const std::shared_ptr<HybridStringTableSpec>& strTab) {
+  this->beginCall();
+  getSyncedFiles_impl(strTab);
+}
+void HybridSFtp::getSyncedFiles_impl(const std::shared_ptr<HybridStringTableSpec>& strTab) {
+  this->ck().GetSyncedFiles(rt::implOf<HybridStringTable>(strTab, "strTab").ck());
+}
+
+void HybridSFtp::getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getLastJsonData_impl(json);
+}
+void HybridSFtp::getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->ck().GetLastJsonData(rt::implOf<HybridJsonObject>(json, "json").ck());
+}
+
+void HybridSFtp::readDirListing(const std::string& handle, const std::shared_ptr<HybridSFtpDirSpec>& dirObj) {
+  this->beginCall();
+  readDirListing_impl(handle, dirObj);
+}
+void HybridSFtp::readDirListing_impl(const std::string& handle, const std::shared_ptr<HybridSFtpDirSpec>& dirObj) {
+  rt::checkNoNul(handle, "handle");
+  if (!this->ck().ReadDirListing(handle.c_str(), rt::implOf<HybridSFtpDir>(dirObj, "dirObj").ck())) throw this->fail("readDirListing");
+}
+std::shared_ptr<Promise<void>> HybridSFtp::readDirListingAsync(const std::string& handle, const std::shared_ptr<HybridSFtpDirSpec>& dirObj) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSFtp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(dirObj);
+  return rt::runAsync<void>("SFtp.readDirListingAsync", std::move(_parts), [_self, handle, dirObj]() {
+    _self->readDirListing_impl(handle, dirObj);
+  });
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridSFtp::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridSFtp::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridSFtp::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridSFtp::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridSFtp::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat