@chilkat/react-native 11.6.1

package/cpp/HybridSsh.cpp

@@ -0,0 +1,1330 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridSsh.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridSecureString.hpp"
+#include "HybridSshKey.hpp"
+#include "HybridStringArray.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridSsh::HybridSsh()
+    : HybridObject(HybridSshSpec::TAG), ChilkatObject<CkSsh>("Ssh", CkSsh::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridSsh::HybridSsh(CkSsh* owned)
+    : HybridObject(HybridSshSpec::TAG), ChilkatObject<CkSsh>("Ssh", owned) {
+  init();
+}
+
+void HybridSsh::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridSsh::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridSsh::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSsh::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSsh::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSsh::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSsh::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridSsh::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridSsh::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridSsh::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridSsh::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridSsh::getAuthFailReason() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_AuthFailReason());
+}
+bool HybridSsh::getCaretControl() {
+  this->beginCall();
+  return this->ck().get_CaretControl();
+}
+void HybridSsh::setCaretControl(bool value) {
+  this->beginCall();
+  this->ck().put_CaretControl(value);
+}
+double HybridSsh::getChannelOpenFailCode() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ChannelOpenFailCode());
+}
+std::string HybridSsh::getChannelOpenFailReason() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ChannelOpenFailReason(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSsh::getClientIdentifier() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ClientIdentifier(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setClientIdentifier(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "clientIdentifier");
+  this->ck().put_ClientIdentifier(value.c_str());
+}
+std::string HybridSsh::getClientIpAddress() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ClientIpAddress(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setClientIpAddress(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "clientIpAddress");
+  this->ck().put_ClientIpAddress(value.c_str());
+}
+double HybridSsh::getConnectTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectTimeoutMs());
+}
+void HybridSsh::setConnectTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_ConnectTimeoutMs(rt::toInt(value, "connectTimeoutMs"));
+}
+double HybridSsh::getDisconnectCode() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_DisconnectCode());
+}
+std::string HybridSsh::getDisconnectReason() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DisconnectReason(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSsh::getForceCipher() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ForceCipher(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setForceCipher(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "forceCipher");
+  this->ck().put_ForceCipher(value.c_str());
+}
+double HybridSsh::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridSsh::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+std::string HybridSsh::getHostKeyAlg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HostKeyAlg(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setHostKeyAlg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "hostKeyAlg");
+  this->ck().put_HostKeyAlg(value.c_str());
+}
+std::string HybridSsh::getHostKeyFingerprint() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HostKeyFingerprint(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSsh::getHttpProxyAuthMethod() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyAuthMethod(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setHttpProxyAuthMethod(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyAuthMethod");
+  this->ck().put_HttpProxyAuthMethod(value.c_str());
+}
+std::string HybridSsh::getHttpProxyDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyDomain(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setHttpProxyDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyDomain");
+  this->ck().put_HttpProxyDomain(value.c_str());
+}
+std::string HybridSsh::getHttpProxyHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setHttpProxyHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyHostname");
+  this->ck().put_HttpProxyHostname(value.c_str());
+}
+std::string HybridSsh::getHttpProxyPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setHttpProxyPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyPassword");
+  this->ck().put_HttpProxyPassword(value.c_str());
+}
+double HybridSsh::getHttpProxyPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HttpProxyPort());
+}
+void HybridSsh::setHttpProxyPort(double value) {
+  this->beginCall();
+  this->ck().put_HttpProxyPort(rt::toInt(value, "httpProxyPort"));
+}
+std::string HybridSsh::getHttpProxyUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setHttpProxyUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyUsername");
+  this->ck().put_HttpProxyUsername(value.c_str());
+}
+double HybridSsh::getIdleTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_IdleTimeoutMs());
+}
+void HybridSsh::setIdleTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_IdleTimeoutMs(rt::toInt(value, "idleTimeoutMs"));
+}
+bool HybridSsh::getIsConnected() {
+  this->beginCall();
+  return this->ck().get_IsConnected();
+}
+bool HybridSsh::getKeepSessionLog() {
+  this->beginCall();
+  return this->ck().get_KeepSessionLog();
+}
+void HybridSsh::setKeepSessionLog(bool value) {
+  this->beginCall();
+  this->ck().put_KeepSessionLog(value);
+}
+double HybridSsh::getMaxPacketSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_MaxPacketSize());
+}
+void HybridSsh::setMaxPacketSize(double value) {
+  this->beginCall();
+  this->ck().put_MaxPacketSize(rt::toInt(value, "maxPacketSize"));
+}
+double HybridSsh::getNumOpenChannels() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumOpenChannels());
+}
+bool HybridSsh::getPasswordChangeRequested() {
+  this->beginCall();
+  return this->ck().get_PasswordChangeRequested();
+}
+bool HybridSsh::getPreferIpv6() {
+  this->beginCall();
+  return this->ck().get_PreferIpv6();
+}
+void HybridSsh::setPreferIpv6(bool value) {
+  this->beginCall();
+  this->ck().put_PreferIpv6(value);
+}
+double HybridSsh::getReadTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ReadTimeoutMs());
+}
+void HybridSsh::setReadTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_ReadTimeoutMs(rt::toInt(value, "readTimeoutMs"));
+}
+std::string HybridSsh::getReqExecCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ReqExecCharset(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setReqExecCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "reqExecCharset");
+  this->ck().put_ReqExecCharset(value.c_str());
+}
+std::string HybridSsh::getSessionLog() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SessionLog(_s);
+  return rt::stdString(_s);
+}
+double HybridSsh::getSoRcvBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoRcvBuf());
+}
+void HybridSsh::setSoRcvBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoRcvBuf(rt::toInt(value, "soRcvBuf"));
+}
+double HybridSsh::getSoSndBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoSndBuf());
+}
+void HybridSsh::setSoSndBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoSndBuf(rt::toInt(value, "soSndBuf"));
+}
+std::string HybridSsh::getSocksHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setSocksHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksHostname");
+  this->ck().put_SocksHostname(value.c_str());
+}
+std::string HybridSsh::getSocksPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setSocksPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksPassword");
+  this->ck().put_SocksPassword(value.c_str());
+}
+double HybridSsh::getSocksPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksPort());
+}
+void HybridSsh::setSocksPort(double value) {
+  this->beginCall();
+  this->ck().put_SocksPort(rt::toInt(value, "socksPort"));
+}
+std::string HybridSsh::getSocksUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setSocksUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksUsername");
+  this->ck().put_SocksUsername(value.c_str());
+}
+double HybridSsh::getSocksVersion() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksVersion());
+}
+void HybridSsh::setSocksVersion(double value) {
+  this->beginCall();
+  this->ck().put_SocksVersion(rt::toInt(value, "socksVersion"));
+}
+bool HybridSsh::getStderrToStdout() {
+  this->beginCall();
+  return this->ck().get_StderrToStdout();
+}
+void HybridSsh::setStderrToStdout(bool value) {
+  this->beginCall();
+  this->ck().put_StderrToStdout(value);
+}
+bool HybridSsh::getTcpNoDelay() {
+  this->beginCall();
+  return this->ck().get_TcpNoDelay();
+}
+void HybridSsh::setTcpNoDelay(bool value) {
+  this->beginCall();
+  this->ck().put_TcpNoDelay(value);
+}
+std::string HybridSsh::getUserAuthBanner() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UserAuthBanner(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setUserAuthBanner(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "userAuthBanner");
+  this->ck().put_UserAuthBanner(value.c_str());
+}
+bool HybridSsh::getEnableCompression() {
+  this->beginCall();
+  return this->ck().get_EnableCompression();
+}
+void HybridSsh::setEnableCompression(bool value) {
+  this->beginCall();
+  this->ck().put_EnableCompression(value);
+}
+bool HybridSsh::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridSsh::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+bool HybridSsh::getStripColorCodes() {
+  this->beginCall();
+  return this->ck().get_StripColorCodes();
+}
+void HybridSsh::setStripColorCodes(bool value) {
+  this->beginCall();
+  this->ck().put_StripColorCodes(value);
+}
+std::string HybridSsh::getServerIdentifier() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ServerIdentifier(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSsh::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridSsh::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+double HybridSsh::getClientPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ClientPort());
+}
+void HybridSsh::setClientPort(double value) {
+  this->beginCall();
+  this->ck().put_ClientPort(rt::toInt(value, "clientPort"));
+}
+bool HybridSsh::getEnableSecrets() {
+  this->beginCall();
+  return this->ck().get_EnableSecrets();
+}
+void HybridSsh::setEnableSecrets(bool value) {
+  this->beginCall();
+  this->ck().put_EnableSecrets(value);
+}
+
+// ---- Methods ----
+
+void HybridSsh::authenticatePk(const std::string& username, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  authenticatePk_impl(username, privateKey);
+}
+void HybridSsh::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>> HybridSsh::authenticatePkAsync(const std::string& username, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(privateKey);
+  return rt::runAsync<void>("Ssh.authenticatePkAsync", std::move(_parts), [_self, username, privateKey]() {
+    _self->authenticatePk_impl(username, privateKey);
+  });
+}
+
+void HybridSsh::authenticatePw(const std::string& login, const std::string& password) {
+  this->beginCall();
+  authenticatePw_impl(login, password);
+}
+void HybridSsh::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>> HybridSsh::authenticatePwAsync(const std::string& login, const std::string& password) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.authenticatePwAsync", std::move(_parts), [_self, login, password]() {
+    _self->authenticatePw_impl(login, password);
+  });
+}
+
+void HybridSsh::authenticatePwPk(const std::string& username, const std::string& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  authenticatePwPk_impl(username, password, privateKey);
+}
+void HybridSsh::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>> HybridSsh::authenticatePwPkAsync(const std::string& username, const std::string& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(privateKey);
+  return rt::runAsync<void>("Ssh.authenticatePwPkAsync", std::move(_parts), [_self, username, password, privateKey]() {
+    _self->authenticatePwPk_impl(username, password, privateKey);
+  });
+}
+
+bool HybridSsh::channelIsOpen(double channelNum) {
+  this->beginCall();
+  return channelIsOpen_impl(channelNum);
+}
+bool HybridSsh::channelIsOpen_impl(double channelNum) {
+  return this->ck().ChannelIsOpen(rt::toInt(channelNum, "channelNum"));
+}
+
+double HybridSsh::channelPoll(double channelNum, double pollTimeoutMs) {
+  this->beginCall();
+  return channelPoll_impl(channelNum, pollTimeoutMs);
+}
+double HybridSsh::channelPoll_impl(double channelNum, double pollTimeoutMs) {
+  return static_cast<double>(this->ck().ChannelPoll(rt::toInt(channelNum, "channelNum"), rt::toInt(pollTimeoutMs, "pollTimeoutMs")));
+}
+std::shared_ptr<Promise<double>> HybridSsh::channelPollAsync(double channelNum, double pollTimeoutMs) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ssh.channelPollAsync", std::move(_parts), [_self, channelNum, pollTimeoutMs]() {
+    return _self->channelPoll_impl(channelNum, pollTimeoutMs);
+  });
+}
+
+double HybridSsh::channelRead(double channelNum) {
+  this->beginCall();
+  return channelRead_impl(channelNum);
+}
+double HybridSsh::channelRead_impl(double channelNum) {
+  return static_cast<double>(this->ck().ChannelRead(rt::toInt(channelNum, "channelNum")));
+}
+std::shared_ptr<Promise<double>> HybridSsh::channelReadAsync(double channelNum) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ssh.channelReadAsync", std::move(_parts), [_self, channelNum]() {
+    return _self->channelRead_impl(channelNum);
+  });
+}
+
+double HybridSsh::channelReadAndPoll(double channelNum, double pollTimeoutMs) {
+  this->beginCall();
+  return channelReadAndPoll_impl(channelNum, pollTimeoutMs);
+}
+double HybridSsh::channelReadAndPoll_impl(double channelNum, double pollTimeoutMs) {
+  return static_cast<double>(this->ck().ChannelReadAndPoll(rt::toInt(channelNum, "channelNum"), rt::toInt(pollTimeoutMs, "pollTimeoutMs")));
+}
+std::shared_ptr<Promise<double>> HybridSsh::channelReadAndPollAsync(double channelNum, double pollTimeoutMs) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ssh.channelReadAndPollAsync", std::move(_parts), [_self, channelNum, pollTimeoutMs]() {
+    return _self->channelReadAndPoll_impl(channelNum, pollTimeoutMs);
+  });
+}
+
+double HybridSsh::channelReadAndPoll2(double channelNum, double pollTimeoutMs, double maxNumBytes) {
+  this->beginCall();
+  return channelReadAndPoll2_impl(channelNum, pollTimeoutMs, maxNumBytes);
+}
+double HybridSsh::channelReadAndPoll2_impl(double channelNum, double pollTimeoutMs, double maxNumBytes) {
+  return static_cast<double>(this->ck().ChannelReadAndPoll2(rt::toInt(channelNum, "channelNum"), rt::toInt(pollTimeoutMs, "pollTimeoutMs"), rt::toInt(maxNumBytes, "maxNumBytes")));
+}
+std::shared_ptr<Promise<double>> HybridSsh::channelReadAndPoll2Async(double channelNum, double pollTimeoutMs, double maxNumBytes) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ssh.channelReadAndPoll2Async", std::move(_parts), [_self, channelNum, pollTimeoutMs, maxNumBytes]() {
+    return _self->channelReadAndPoll2_impl(channelNum, pollTimeoutMs, maxNumBytes);
+  });
+}
+
+void HybridSsh::channelReceiveToClose(double channelNum) {
+  this->beginCall();
+  channelReceiveToClose_impl(channelNum);
+}
+void HybridSsh::channelReceiveToClose_impl(double channelNum) {
+  if (!this->ck().ChannelReceiveToClose(rt::toInt(channelNum, "channelNum"))) throw this->fail("channelReceiveToClose");
+}
+std::shared_ptr<Promise<void>> HybridSsh::channelReceiveToCloseAsync(double channelNum) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.channelReceiveToCloseAsync", std::move(_parts), [_self, channelNum]() {
+    _self->channelReceiveToClose_impl(channelNum);
+  });
+}
+
+void HybridSsh::channelReceiveUntilMatch(double channelNum, const std::string& matchPattern, const std::string& charset, bool caseSensitive) {
+  this->beginCall();
+  channelReceiveUntilMatch_impl(channelNum, matchPattern, charset, caseSensitive);
+}
+void HybridSsh::channelReceiveUntilMatch_impl(double channelNum, const std::string& matchPattern, const std::string& charset, bool caseSensitive) {
+  rt::checkNoNul(matchPattern, "matchPattern");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().ChannelReceiveUntilMatch(rt::toInt(channelNum, "channelNum"), matchPattern.c_str(), charset.c_str(), caseSensitive)) throw this->fail("channelReceiveUntilMatch");
+}
+std::shared_ptr<Promise<void>> HybridSsh::channelReceiveUntilMatchAsync(double channelNum, const std::string& matchPattern, const std::string& charset, bool caseSensitive) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.channelReceiveUntilMatchAsync", std::move(_parts), [_self, channelNum, matchPattern, charset, caseSensitive]() {
+    _self->channelReceiveUntilMatch_impl(channelNum, matchPattern, charset, caseSensitive);
+  });
+}
+
+void HybridSsh::channelReceiveUntilMatchN(double channelNum, const std::shared_ptr<HybridStringArraySpec>& matchPatterns, const std::string& charset, bool caseSensitive) {
+  this->beginCall();
+  channelReceiveUntilMatchN_impl(channelNum, matchPatterns, charset, caseSensitive);
+}
+void HybridSsh::channelReceiveUntilMatchN_impl(double channelNum, const std::shared_ptr<HybridStringArraySpec>& matchPatterns, const std::string& charset, bool caseSensitive) {
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().ChannelReceiveUntilMatchN(rt::toInt(channelNum, "channelNum"), rt::implOf<HybridStringArray>(matchPatterns, "matchPatterns").ck(), charset.c_str(), caseSensitive)) throw this->fail("channelReceiveUntilMatchN");
+}
+std::shared_ptr<Promise<void>> HybridSsh::channelReceiveUntilMatchNAsync(double channelNum, const std::shared_ptr<HybridStringArraySpec>& matchPatterns, const std::string& charset, bool caseSensitive) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(matchPatterns);
+  return rt::runAsync<void>("Ssh.channelReceiveUntilMatchNAsync", std::move(_parts), [_self, channelNum, matchPatterns, charset, caseSensitive]() {
+    _self->channelReceiveUntilMatchN_impl(channelNum, matchPatterns, charset, caseSensitive);
+  });
+}
+
+bool HybridSsh::channelReceivedClose(double channelNum) {
+  this->beginCall();
+  return channelReceivedClose_impl(channelNum);
+}
+bool HybridSsh::channelReceivedClose_impl(double channelNum) {
+  return this->ck().ChannelReceivedClose(rt::toInt(channelNum, "channelNum"));
+}
+
+bool HybridSsh::channelReceivedEof(double channelNum) {
+  this->beginCall();
+  return channelReceivedEof_impl(channelNum);
+}
+bool HybridSsh::channelReceivedEof_impl(double channelNum) {
+  return this->ck().ChannelReceivedEof(rt::toInt(channelNum, "channelNum"));
+}
+
+bool HybridSsh::channelReceivedExitStatus(double channelNum) {
+  this->beginCall();
+  return channelReceivedExitStatus_impl(channelNum);
+}
+bool HybridSsh::channelReceivedExitStatus_impl(double channelNum) {
+  return this->ck().ChannelReceivedExitStatus(rt::toInt(channelNum, "channelNum"));
+}
+
+void HybridSsh::channelRelease(double channelNum) {
+  this->beginCall();
+  channelRelease_impl(channelNum);
+}
+void HybridSsh::channelRelease_impl(double channelNum) {
+  this->ck().ChannelRelease(rt::toInt(channelNum, "channelNum"));
+}
+
+void HybridSsh::channelSendClose(double channelNum) {
+  this->beginCall();
+  channelSendClose_impl(channelNum);
+}
+void HybridSsh::channelSendClose_impl(double channelNum) {
+  if (!this->ck().ChannelSendClose(rt::toInt(channelNum, "channelNum"))) throw this->fail("channelSendClose");
+}
+std::shared_ptr<Promise<void>> HybridSsh::channelSendCloseAsync(double channelNum) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.channelSendCloseAsync", std::move(_parts), [_self, channelNum]() {
+    _self->channelSendClose_impl(channelNum);
+  });
+}
+
+void HybridSsh::channelSendEof(double channelNum) {
+  this->beginCall();
+  channelSendEof_impl(channelNum);
+}
+void HybridSsh::channelSendEof_impl(double channelNum) {
+  if (!this->ck().ChannelSendEof(rt::toInt(channelNum, "channelNum"))) throw this->fail("channelSendEof");
+}
+std::shared_ptr<Promise<void>> HybridSsh::channelSendEofAsync(double channelNum) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.channelSendEofAsync", std::move(_parts), [_self, channelNum]() {
+    _self->channelSendEof_impl(channelNum);
+  });
+}
+
+void HybridSsh::channelSendString(double channelNum, const std::string& textData, const std::string& charset) {
+  this->beginCall();
+  channelSendString_impl(channelNum, textData, charset);
+}
+void HybridSsh::channelSendString_impl(double channelNum, const std::string& textData, const std::string& charset) {
+  rt::checkNoNul(textData, "textData");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().ChannelSendString(rt::toInt(channelNum, "channelNum"), textData.c_str(), charset.c_str())) throw this->fail("channelSendString");
+}
+std::shared_ptr<Promise<void>> HybridSsh::channelSendStringAsync(double channelNum, const std::string& textData, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.channelSendStringAsync", std::move(_parts), [_self, channelNum, textData, charset]() {
+    _self->channelSendString_impl(channelNum, textData, charset);
+  });
+}
+
+bool HybridSsh::checkConnection() {
+  this->beginCall();
+  return checkConnection_impl();
+}
+bool HybridSsh::checkConnection_impl() {
+  return this->ck().CheckConnection();
+}
+
+void HybridSsh::clearTtyModes() {
+  this->beginCall();
+  clearTtyModes_impl();
+}
+void HybridSsh::clearTtyModes_impl() {
+  this->ck().ClearTtyModes();
+}
+
+void HybridSsh::connect(const std::string& domainName, double port) {
+  this->beginCall();
+  connect_impl(domainName, port);
+}
+void HybridSsh::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>> HybridSsh::connectAsync(const std::string& domainName, double port) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.connectAsync", std::move(_parts), [_self, domainName, port]() {
+    _self->connect_impl(domainName, port);
+  });
+}
+
+void HybridSsh::connectThroughSsh(const std::shared_ptr<HybridSshSpec>& ssh, const std::string& hostname, double port) {
+  this->beginCall();
+  connectThroughSsh_impl(ssh, hostname, port);
+}
+void HybridSsh::connectThroughSsh_impl(const std::shared_ptr<HybridSshSpec>& ssh, const std::string& hostname, double port) {
+  rt::checkNoNul(hostname, "hostname");
+  if (!this->ck().ConnectThroughSsh(rt::implOf<HybridSsh>(ssh, "ssh").ck(), hostname.c_str(), rt::toInt(port, "port"))) throw this->fail("connectThroughSsh");
+}
+std::shared_ptr<Promise<void>> HybridSsh::connectThroughSshAsync(const std::shared_ptr<HybridSshSpec>& ssh, const std::string& hostname, double port) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(ssh);
+  return rt::runAsync<void>("Ssh.connectThroughSshAsync", std::move(_parts), [_self, ssh, hostname, port]() {
+    _self->connectThroughSsh_impl(ssh, hostname, port);
+  });
+}
+
+std::string HybridSsh::continueKeyboardAuth(const std::string& response) {
+  this->beginCall();
+  return continueKeyboardAuth_impl(response);
+}
+std::string HybridSsh::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>> HybridSsh::continueKeyboardAuthAsync(const std::string& response) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ssh.continueKeyboardAuthAsync", std::move(_parts), [_self, response]() {
+    return _self->continueKeyboardAuth_impl(response);
+  });
+}
+
+void HybridSsh::disconnect() {
+  this->beginCall();
+  disconnect_impl();
+}
+void HybridSsh::disconnect_impl() {
+  this->ck().Disconnect();
+}
+
+double HybridSsh::getChannelExitStatus(double channelNum) {
+  this->beginCall();
+  return getChannelExitStatus_impl(channelNum);
+}
+double HybridSsh::getChannelExitStatus_impl(double channelNum) {
+  return static_cast<double>(this->ck().GetChannelExitStatus(rt::toInt(channelNum, "channelNum")));
+}
+
+double HybridSsh::getChannelNumber(double index) {
+  this->beginCall();
+  return getChannelNumber_impl(index);
+}
+double HybridSsh::getChannelNumber_impl(double index) {
+  return static_cast<double>(this->ck().GetChannelNumber(rt::toInt(index, "index")));
+}
+
+std::string HybridSsh::getChannelType(double index) {
+  this->beginCall();
+  return getChannelType_impl(index);
+}
+std::string HybridSsh::getChannelType_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetChannelType(rt::toInt(index, "index"), _out)) throw this->fail("getChannelType");
+  return rt::stdString(_out);
+}
+
+double HybridSsh::getReceivedNumBytes(double channelNum) {
+  this->beginCall();
+  return getReceivedNumBytes_impl(channelNum);
+}
+double HybridSsh::getReceivedNumBytes_impl(double channelNum) {
+  return static_cast<double>(this->ck().GetReceivedNumBytes(rt::toInt(channelNum, "channelNum")));
+}
+
+std::string HybridSsh::getReceivedStderrText(double channelNum, const std::string& charset) {
+  this->beginCall();
+  return getReceivedStderrText_impl(channelNum, charset);
+}
+std::string HybridSsh::getReceivedStderrText_impl(double channelNum, const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().GetReceivedStderrText(rt::toInt(channelNum, "channelNum"), charset.c_str(), _out)) throw this->fail("getReceivedStderrText");
+  return rt::stdString(_out);
+}
+
+std::string HybridSsh::getReceivedText(double channelNum, const std::string& charset) {
+  this->beginCall();
+  return getReceivedText_impl(channelNum, charset);
+}
+std::string HybridSsh::getReceivedText_impl(double channelNum, const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().GetReceivedText(rt::toInt(channelNum, "channelNum"), charset.c_str(), _out)) throw this->fail("getReceivedText");
+  return rt::stdString(_out);
+}
+
+std::string HybridSsh::getReceivedTextS(double channelNum, const std::string& substr, const std::string& charset) {
+  this->beginCall();
+  return getReceivedTextS_impl(channelNum, substr, charset);
+}
+std::string HybridSsh::getReceivedTextS_impl(double channelNum, const std::string& substr, const std::string& charset) {
+  rt::checkNoNul(substr, "substr");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().GetReceivedTextS(rt::toInt(channelNum, "channelNum"), substr.c_str(), charset.c_str(), _out)) throw this->fail("getReceivedTextS");
+  return rt::stdString(_out);
+}
+
+double HybridSsh::openCustomChannel(const std::string& channelType) {
+  this->beginCall();
+  return openCustomChannel_impl(channelType);
+}
+double HybridSsh::openCustomChannel_impl(const std::string& channelType) {
+  rt::checkNoNul(channelType, "channelType");
+  return static_cast<double>(this->ck().OpenCustomChannel(channelType.c_str()));
+}
+std::shared_ptr<Promise<double>> HybridSsh::openCustomChannelAsync(const std::string& channelType) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ssh.openCustomChannelAsync", std::move(_parts), [_self, channelType]() {
+    return _self->openCustomChannel_impl(channelType);
+  });
+}
+
+double HybridSsh::openDirectTcpIpChannel(const std::string& targetHostname, double targetPort) {
+  this->beginCall();
+  return openDirectTcpIpChannel_impl(targetHostname, targetPort);
+}
+double HybridSsh::openDirectTcpIpChannel_impl(const std::string& targetHostname, double targetPort) {
+  rt::checkNoNul(targetHostname, "targetHostname");
+  return static_cast<double>(this->ck().OpenDirectTcpIpChannel(targetHostname.c_str(), rt::toInt(targetPort, "targetPort")));
+}
+std::shared_ptr<Promise<double>> HybridSsh::openDirectTcpIpChannelAsync(const std::string& targetHostname, double targetPort) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ssh.openDirectTcpIpChannelAsync", std::move(_parts), [_self, targetHostname, targetPort]() {
+    return _self->openDirectTcpIpChannel_impl(targetHostname, targetPort);
+  });
+}
+
+double HybridSsh::openSessionChannel() {
+  this->beginCall();
+  return openSessionChannel_impl();
+}
+double HybridSsh::openSessionChannel_impl() {
+  return static_cast<double>(this->ck().OpenSessionChannel());
+}
+std::shared_ptr<Promise<double>> HybridSsh::openSessionChannelAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ssh.openSessionChannelAsync", std::move(_parts), [_self]() {
+    return _self->openSessionChannel_impl();
+  });
+}
+
+std::string HybridSsh::peekReceivedText(double channelNum, const std::string& charset) {
+  this->beginCall();
+  return peekReceivedText_impl(channelNum, charset);
+}
+std::string HybridSsh::peekReceivedText_impl(double channelNum, const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().PeekReceivedText(rt::toInt(channelNum, "channelNum"), charset.c_str(), _out)) throw this->fail("peekReceivedText");
+  return rt::stdString(_out);
+}
+
+void HybridSsh::reKey() {
+  this->beginCall();
+  reKey_impl();
+}
+void HybridSsh::reKey_impl() {
+  if (!this->ck().ReKey()) throw this->fail("reKey");
+}
+std::shared_ptr<Promise<void>> HybridSsh::reKeyAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.reKeyAsync", std::move(_parts), [_self]() {
+    _self->reKey_impl();
+  });
+}
+
+void HybridSsh::sendIgnore() {
+  this->beginCall();
+  sendIgnore_impl();
+}
+void HybridSsh::sendIgnore_impl() {
+  if (!this->ck().SendIgnore()) throw this->fail("sendIgnore");
+}
+std::shared_ptr<Promise<void>> HybridSsh::sendIgnoreAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.sendIgnoreAsync", std::move(_parts), [_self]() {
+    _self->sendIgnore_impl();
+  });
+}
+
+void HybridSsh::sendReqExec(double channelNum, const std::string& commandLine) {
+  this->beginCall();
+  sendReqExec_impl(channelNum, commandLine);
+}
+void HybridSsh::sendReqExec_impl(double channelNum, const std::string& commandLine) {
+  rt::checkNoNul(commandLine, "commandLine");
+  if (!this->ck().SendReqExec(rt::toInt(channelNum, "channelNum"), commandLine.c_str())) throw this->fail("sendReqExec");
+}
+std::shared_ptr<Promise<void>> HybridSsh::sendReqExecAsync(double channelNum, const std::string& commandLine) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.sendReqExecAsync", std::move(_parts), [_self, channelNum, commandLine]() {
+    _self->sendReqExec_impl(channelNum, commandLine);
+  });
+}
+
+void HybridSsh::sendReqPty(double channelNum, const std::string& termType, double widthInChars, double heightInChars, double widthInPixels, double heightInPixels) {
+  this->beginCall();
+  sendReqPty_impl(channelNum, termType, widthInChars, heightInChars, widthInPixels, heightInPixels);
+}
+void HybridSsh::sendReqPty_impl(double channelNum, const std::string& termType, double widthInChars, double heightInChars, double widthInPixels, double heightInPixels) {
+  rt::checkNoNul(termType, "termType");
+  if (!this->ck().SendReqPty(rt::toInt(channelNum, "channelNum"), termType.c_str(), rt::toInt(widthInChars, "widthInChars"), rt::toInt(heightInChars, "heightInChars"), rt::toInt(widthInPixels, "widthInPixels"), rt::toInt(heightInPixels, "heightInPixels"))) throw this->fail("sendReqPty");
+}
+std::shared_ptr<Promise<void>> HybridSsh::sendReqPtyAsync(double channelNum, const std::string& termType, double widthInChars, double heightInChars, double widthInPixels, double heightInPixels) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.sendReqPtyAsync", std::move(_parts), [_self, channelNum, termType, widthInChars, heightInChars, widthInPixels, heightInPixels]() {
+    _self->sendReqPty_impl(channelNum, termType, widthInChars, heightInChars, widthInPixels, heightInPixels);
+  });
+}
+
+void HybridSsh::sendReqSetEnv(double channelNum, const std::string& name, const std::string& value) {
+  this->beginCall();
+  sendReqSetEnv_impl(channelNum, name, value);
+}
+void HybridSsh::sendReqSetEnv_impl(double channelNum, const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().SendReqSetEnv(rt::toInt(channelNum, "channelNum"), name.c_str(), value.c_str())) throw this->fail("sendReqSetEnv");
+}
+std::shared_ptr<Promise<void>> HybridSsh::sendReqSetEnvAsync(double channelNum, const std::string& name, const std::string& value) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.sendReqSetEnvAsync", std::move(_parts), [_self, channelNum, name, value]() {
+    _self->sendReqSetEnv_impl(channelNum, name, value);
+  });
+}
+
+void HybridSsh::sendReqShell(double channelNum) {
+  this->beginCall();
+  sendReqShell_impl(channelNum);
+}
+void HybridSsh::sendReqShell_impl(double channelNum) {
+  if (!this->ck().SendReqShell(rt::toInt(channelNum, "channelNum"))) throw this->fail("sendReqShell");
+}
+std::shared_ptr<Promise<void>> HybridSsh::sendReqShellAsync(double channelNum) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.sendReqShellAsync", std::move(_parts), [_self, channelNum]() {
+    _self->sendReqShell_impl(channelNum);
+  });
+}
+
+void HybridSsh::sendReqSignal(double channelNum, const std::string& signalName) {
+  this->beginCall();
+  sendReqSignal_impl(channelNum, signalName);
+}
+void HybridSsh::sendReqSignal_impl(double channelNum, const std::string& signalName) {
+  rt::checkNoNul(signalName, "signalName");
+  if (!this->ck().SendReqSignal(rt::toInt(channelNum, "channelNum"), signalName.c_str())) throw this->fail("sendReqSignal");
+}
+std::shared_ptr<Promise<void>> HybridSsh::sendReqSignalAsync(double channelNum, const std::string& signalName) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.sendReqSignalAsync", std::move(_parts), [_self, channelNum, signalName]() {
+    _self->sendReqSignal_impl(channelNum, signalName);
+  });
+}
+
+void HybridSsh::sendReqSubsystem(double channelNum, const std::string& subsystemName) {
+  this->beginCall();
+  sendReqSubsystem_impl(channelNum, subsystemName);
+}
+void HybridSsh::sendReqSubsystem_impl(double channelNum, const std::string& subsystemName) {
+  rt::checkNoNul(subsystemName, "subsystemName");
+  if (!this->ck().SendReqSubsystem(rt::toInt(channelNum, "channelNum"), subsystemName.c_str())) throw this->fail("sendReqSubsystem");
+}
+std::shared_ptr<Promise<void>> HybridSsh::sendReqSubsystemAsync(double channelNum, const std::string& subsystemName) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.sendReqSubsystemAsync", std::move(_parts), [_self, channelNum, subsystemName]() {
+    _self->sendReqSubsystem_impl(channelNum, subsystemName);
+  });
+}
+
+void HybridSsh::sendReqWindowChange(double channelNum, double widthInChars, double heightInRows, double pixWidth, double pixHeight) {
+  this->beginCall();
+  sendReqWindowChange_impl(channelNum, widthInChars, heightInRows, pixWidth, pixHeight);
+}
+void HybridSsh::sendReqWindowChange_impl(double channelNum, double widthInChars, double heightInRows, double pixWidth, double pixHeight) {
+  if (!this->ck().SendReqWindowChange(rt::toInt(channelNum, "channelNum"), rt::toInt(widthInChars, "widthInChars"), rt::toInt(heightInRows, "heightInRows"), rt::toInt(pixWidth, "pixWidth"), rt::toInt(pixHeight, "pixHeight"))) throw this->fail("sendReqWindowChange");
+}
+std::shared_ptr<Promise<void>> HybridSsh::sendReqWindowChangeAsync(double channelNum, double widthInChars, double heightInRows, double pixWidth, double pixHeight) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.sendReqWindowChangeAsync", std::move(_parts), [_self, channelNum, widthInChars, heightInRows, pixWidth, pixHeight]() {
+    _self->sendReqWindowChange_impl(channelNum, widthInChars, heightInRows, pixWidth, pixHeight);
+  });
+}
+
+void HybridSsh::sendReqX11Forwarding(double channelNum, bool singleConnection, const std::string& authProt, const std::string& authCookie, double screenNum) {
+  this->beginCall();
+  sendReqX11Forwarding_impl(channelNum, singleConnection, authProt, authCookie, screenNum);
+}
+void HybridSsh::sendReqX11Forwarding_impl(double channelNum, bool singleConnection, const std::string& authProt, const std::string& authCookie, double screenNum) {
+  rt::checkNoNul(authProt, "authProt");
+  rt::checkNoNul(authCookie, "authCookie");
+  if (!this->ck().SendReqX11Forwarding(rt::toInt(channelNum, "channelNum"), singleConnection, authProt.c_str(), authCookie.c_str(), rt::toInt(screenNum, "screenNum"))) throw this->fail("sendReqX11Forwarding");
+}
+std::shared_ptr<Promise<void>> HybridSsh::sendReqX11ForwardingAsync(double channelNum, bool singleConnection, const std::string& authProt, const std::string& authCookie, double screenNum) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.sendReqX11ForwardingAsync", std::move(_parts), [_self, channelNum, singleConnection, authProt, authCookie, screenNum]() {
+    _self->sendReqX11Forwarding_impl(channelNum, singleConnection, authProt, authCookie, screenNum);
+  });
+}
+
+void HybridSsh::sendReqXonXoff(double channelNum, bool clientCanDo) {
+  this->beginCall();
+  sendReqXonXoff_impl(channelNum, clientCanDo);
+}
+void HybridSsh::sendReqXonXoff_impl(double channelNum, bool clientCanDo) {
+  if (!this->ck().SendReqXonXoff(rt::toInt(channelNum, "channelNum"), clientCanDo)) throw this->fail("sendReqXonXoff");
+}
+std::shared_ptr<Promise<void>> HybridSsh::sendReqXonXoffAsync(double channelNum, bool clientCanDo) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Ssh.sendReqXonXoffAsync", std::move(_parts), [_self, channelNum, clientCanDo]() {
+    _self->sendReqXonXoff_impl(channelNum, clientCanDo);
+  });
+}
+
+void HybridSsh::setTtyMode(const std::string& ttyName, double ttyValue) {
+  this->beginCall();
+  setTtyMode_impl(ttyName, ttyValue);
+}
+void HybridSsh::setTtyMode_impl(const std::string& ttyName, double ttyValue) {
+  rt::checkNoNul(ttyName, "ttyName");
+  if (!this->ck().SetTtyMode(ttyName.c_str(), rt::toInt(ttyValue, "ttyValue"))) throw this->fail("setTtyMode");
+}
+
+std::string HybridSsh::startKeyboardAuth(const std::string& login) {
+  this->beginCall();
+  return startKeyboardAuth_impl(login);
+}
+std::string HybridSsh::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>> HybridSsh::startKeyboardAuthAsync(const std::string& login) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ssh.startKeyboardAuthAsync", std::move(_parts), [_self, login]() {
+    return _self->startKeyboardAuth_impl(login);
+  });
+}
+
+double HybridSsh::waitForChannelMessage(double pollTimeoutMs) {
+  this->beginCall();
+  return waitForChannelMessage_impl(pollTimeoutMs);
+}
+double HybridSsh::waitForChannelMessage_impl(double pollTimeoutMs) {
+  return static_cast<double>(this->ck().WaitForChannelMessage(rt::toInt(pollTimeoutMs, "pollTimeoutMs")));
+}
+std::shared_ptr<Promise<double>> HybridSsh::waitForChannelMessageAsync(double pollTimeoutMs) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ssh.waitForChannelMessageAsync", std::move(_parts), [_self, pollTimeoutMs]() {
+    return _self->waitForChannelMessage_impl(pollTimeoutMs);
+  });
+}
+
+std::string HybridSsh::quickCommand(const std::string& command, const std::string& charset) {
+  this->beginCall();
+  return quickCommand_impl(command, charset);
+}
+std::string HybridSsh::quickCommand_impl(const std::string& command, const std::string& charset) {
+  rt::checkNoNul(command, "command");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().QuickCommand(command.c_str(), charset.c_str(), _out)) throw this->fail("quickCommand");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSsh::quickCommandAsync(const std::string& command, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ssh.quickCommandAsync", std::move(_parts), [_self, command, charset]() {
+    return _self->quickCommand_impl(command, charset);
+  });
+}
+
+double HybridSsh::quickShell() {
+  this->beginCall();
+  return quickShell_impl();
+}
+double HybridSsh::quickShell_impl() {
+  return static_cast<double>(this->ck().QuickShell());
+}
+std::shared_ptr<Promise<double>> HybridSsh::quickShellAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ssh.quickShellAsync", std::move(_parts), [_self]() {
+    return _self->quickShell_impl();
+  });
+}
+
+double HybridSsh::quickCmdSend(const std::string& command) {
+  this->beginCall();
+  return quickCmdSend_impl(command);
+}
+double HybridSsh::quickCmdSend_impl(const std::string& command) {
+  rt::checkNoNul(command, "command");
+  return static_cast<double>(this->ck().QuickCmdSend(command.c_str()));
+}
+std::shared_ptr<Promise<double>> HybridSsh::quickCmdSendAsync(const std::string& command) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ssh.quickCmdSendAsync", std::move(_parts), [_self, command]() {
+    return _self->quickCmdSend_impl(command);
+  });
+}
+
+double HybridSsh::quickCmdCheck(double pollTimeoutMs) {
+  this->beginCall();
+  return quickCmdCheck_impl(pollTimeoutMs);
+}
+double HybridSsh::quickCmdCheck_impl(double pollTimeoutMs) {
+  return static_cast<double>(this->ck().QuickCmdCheck(rt::toInt(pollTimeoutMs, "pollTimeoutMs")));
+}
+std::shared_ptr<Promise<double>> HybridSsh::quickCmdCheckAsync(double pollTimeoutMs) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Ssh.quickCmdCheckAsync", std::move(_parts), [_self, pollTimeoutMs]() {
+    return _self->quickCmdCheck_impl(pollTimeoutMs);
+  });
+}
+
+void HybridSsh::authenticateSecPw(const std::shared_ptr<HybridSecureStringSpec>& login, const std::shared_ptr<HybridSecureStringSpec>& password) {
+  this->beginCall();
+  authenticateSecPw_impl(login, password);
+}
+void HybridSsh::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>> HybridSsh::authenticateSecPwAsync(const std::shared_ptr<HybridSecureStringSpec>& login, const std::shared_ptr<HybridSecureStringSpec>& password) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(login);
+  _parts.push_back(password);
+  return rt::runAsync<void>("Ssh.authenticateSecPwAsync", std::move(_parts), [_self, login, password]() {
+    _self->authenticateSecPw_impl(login, password);
+  });
+}
+
+void HybridSsh::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 HybridSsh::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>> HybridSsh::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<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(username);
+  _parts.push_back(password);
+  _parts.push_back(privateKey);
+  return rt::runAsync<void>("Ssh.authenticateSecPwPkAsync", std::move(_parts), [_self, username, password, privateKey]() {
+    _self->authenticateSecPwPk_impl(username, password, privateKey);
+  });
+}
+
+std::string HybridSsh::getAuthMethods() {
+  this->beginCall();
+  return getAuthMethods_impl();
+}
+std::string HybridSsh::getAuthMethods_impl() {
+  CkString _out;
+  if (!this->ck().GetAuthMethods(_out)) throw this->fail("getAuthMethods");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSsh::getAuthMethodsAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSsh>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Ssh.getAuthMethodsAsync", std::move(_parts), [_self]() {
+    return _self->getAuthMethods_impl();
+  });
+}
+
+std::string HybridSsh::getHostKeyFP(const std::string& hashAlg, bool includeKeyType, bool includeHashName) {
+  this->beginCall();
+  return getHostKeyFP_impl(hashAlg, includeKeyType, includeHashName);
+}
+std::string HybridSsh::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 HybridSsh::setAllowedAlgorithms(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  setAllowedAlgorithms_impl(json);
+}
+void HybridSsh::setAllowedAlgorithms_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().SetAllowedAlgorithms(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("setAllowedAlgorithms");
+}
+
+void HybridSsh::getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getLastJsonData_impl(json);
+}
+void HybridSsh::getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->ck().GetLastJsonData(rt::implOf<HybridJsonObject>(json, "json").ck());
+}
+
+void HybridSsh::getReceivedSb(double channelNum, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  getReceivedSb_impl(channelNum, charset, sb);
+}
+void HybridSsh::getReceivedSb_impl(double channelNum, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().GetReceivedSb(rt::toInt(channelNum, "channelNum"), charset.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("getReceivedSb");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridSsh::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridSsh::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridSsh::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridSsh::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridSsh::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat