@chilkat/react-native 11.6.1

package/cpp/HybridSshTunnel.cpp

@@ -0,0 +1,687 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridSshTunnel.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridSecureString.hpp"
+#include "HybridSsh.hpp"
+#include "HybridSshKey.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridSshTunnel::HybridSshTunnel()
+    : HybridObject(HybridSshTunnelSpec::TAG), ChilkatObject<CkSshTunnel>("SshTunnel", CkSshTunnel::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridSshTunnel::HybridSshTunnel(CkSshTunnel* owned)
+    : HybridObject(HybridSshTunnelSpec::TAG), ChilkatObject<CkSshTunnel>("SshTunnel", owned) {
+  init();
+}
+
+void HybridSshTunnel::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridSshTunnel::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridSshTunnel::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSshTunnel::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSshTunnel::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSshTunnel::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSshTunnel::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridSshTunnel::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridSshTunnel::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridSshTunnel::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridSshTunnel::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridSshTunnel::getAcceptLog() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AcceptLog(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setAcceptLog(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "acceptLog");
+  this->ck().put_AcceptLog(value.c_str());
+}
+std::string HybridSshTunnel::getAcceptLogPath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AcceptLogPath(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setAcceptLogPath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "acceptLogPath");
+  this->ck().put_AcceptLogPath(value.c_str());
+}
+double HybridSshTunnel::getConnectTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectTimeoutMs());
+}
+void HybridSshTunnel::setConnectTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_ConnectTimeoutMs(rt::toInt(value, "connectTimeoutMs"));
+}
+std::string HybridSshTunnel::getDestHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DestHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setDestHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "destHostname");
+  this->ck().put_DestHostname(value.c_str());
+}
+double HybridSshTunnel::getDestPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_DestPort());
+}
+void HybridSshTunnel::setDestPort(double value) {
+  this->beginCall();
+  this->ck().put_DestPort(rt::toInt(value, "destPort"));
+}
+bool HybridSshTunnel::getDynamicPortForwarding() {
+  this->beginCall();
+  return this->ck().get_DynamicPortForwarding();
+}
+void HybridSshTunnel::setDynamicPortForwarding(bool value) {
+  this->beginCall();
+  this->ck().put_DynamicPortForwarding(value);
+}
+std::string HybridSshTunnel::getHttpProxyAuthMethod() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyAuthMethod(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setHttpProxyAuthMethod(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyAuthMethod");
+  this->ck().put_HttpProxyAuthMethod(value.c_str());
+}
+std::string HybridSshTunnel::getHttpProxyDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyDomain(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setHttpProxyDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyDomain");
+  this->ck().put_HttpProxyDomain(value.c_str());
+}
+std::string HybridSshTunnel::getHttpProxyHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setHttpProxyHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyHostname");
+  this->ck().put_HttpProxyHostname(value.c_str());
+}
+std::string HybridSshTunnel::getHttpProxyPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setHttpProxyPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyPassword");
+  this->ck().put_HttpProxyPassword(value.c_str());
+}
+double HybridSshTunnel::getHttpProxyPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HttpProxyPort());
+}
+void HybridSshTunnel::setHttpProxyPort(double value) {
+  this->beginCall();
+  this->ck().put_HttpProxyPort(rt::toInt(value, "httpProxyPort"));
+}
+std::string HybridSshTunnel::getHttpProxyUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setHttpProxyUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyUsername");
+  this->ck().put_HttpProxyUsername(value.c_str());
+}
+double HybridSshTunnel::getIdleTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_IdleTimeoutMs());
+}
+void HybridSshTunnel::setIdleTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_IdleTimeoutMs(rt::toInt(value, "idleTimeoutMs"));
+}
+std::string HybridSshTunnel::getInboundSocksPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_InboundSocksPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setInboundSocksPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "inboundSocksPassword");
+  this->ck().put_InboundSocksPassword(value.c_str());
+}
+std::string HybridSshTunnel::getInboundSocksUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_InboundSocksUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setInboundSocksUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "inboundSocksUsername");
+  this->ck().put_InboundSocksUsername(value.c_str());
+}
+bool HybridSshTunnel::getIsAccepting() {
+  this->beginCall();
+  return this->ck().get_IsAccepting();
+}
+bool HybridSshTunnel::getKeepAcceptLog() {
+  this->beginCall();
+  return this->ck().get_KeepAcceptLog();
+}
+void HybridSshTunnel::setKeepAcceptLog(bool value) {
+  this->beginCall();
+  this->ck().put_KeepAcceptLog(value);
+}
+bool HybridSshTunnel::getKeepTunnelLog() {
+  this->beginCall();
+  return this->ck().get_KeepTunnelLog();
+}
+void HybridSshTunnel::setKeepTunnelLog(bool value) {
+  this->beginCall();
+  this->ck().put_KeepTunnelLog(value);
+}
+std::string HybridSshTunnel::getListenBindIpAddress() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ListenBindIpAddress(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setListenBindIpAddress(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "listenBindIpAddress");
+  this->ck().put_ListenBindIpAddress(value.c_str());
+}
+double HybridSshTunnel::getListenPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ListenPort());
+}
+std::string HybridSshTunnel::getOutboundBindIpAddress() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OutboundBindIpAddress(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setOutboundBindIpAddress(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "outboundBindIpAddress");
+  this->ck().put_OutboundBindIpAddress(value.c_str());
+}
+double HybridSshTunnel::getOutboundBindPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_OutboundBindPort());
+}
+void HybridSshTunnel::setOutboundBindPort(double value) {
+  this->beginCall();
+  this->ck().put_OutboundBindPort(rt::toInt(value, "outboundBindPort"));
+}
+double HybridSshTunnel::getSoRcvBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoRcvBuf());
+}
+void HybridSshTunnel::setSoRcvBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoRcvBuf(rt::toInt(value, "soRcvBuf"));
+}
+double HybridSshTunnel::getSoSndBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoSndBuf());
+}
+void HybridSshTunnel::setSoSndBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoSndBuf(rt::toInt(value, "soSndBuf"));
+}
+std::string HybridSshTunnel::getSocksHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setSocksHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksHostname");
+  this->ck().put_SocksHostname(value.c_str());
+}
+std::string HybridSshTunnel::getSocksPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setSocksPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksPassword");
+  this->ck().put_SocksPassword(value.c_str());
+}
+double HybridSshTunnel::getSocksPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksPort());
+}
+void HybridSshTunnel::setSocksPort(double value) {
+  this->beginCall();
+  this->ck().put_SocksPort(rt::toInt(value, "socksPort"));
+}
+std::string HybridSshTunnel::getSocksUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setSocksUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksUsername");
+  this->ck().put_SocksUsername(value.c_str());
+}
+double HybridSshTunnel::getSocksVersion() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksVersion());
+}
+void HybridSshTunnel::setSocksVersion(double value) {
+  this->beginCall();
+  this->ck().put_SocksVersion(rt::toInt(value, "socksVersion"));
+}
+bool HybridSshTunnel::getTcpNoDelay() {
+  this->beginCall();
+  return this->ck().get_TcpNoDelay();
+}
+void HybridSshTunnel::setTcpNoDelay(bool value) {
+  this->beginCall();
+  this->ck().put_TcpNoDelay(value);
+}
+std::string HybridSshTunnel::getTunnelLog() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TunnelLog(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setTunnelLog(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "tunnelLog");
+  this->ck().put_TunnelLog(value.c_str());
+}
+std::string HybridSshTunnel::getTunnelLogPath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TunnelLogPath(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setTunnelLogPath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "tunnelLogPath");
+  this->ck().put_TunnelLogPath(value.c_str());
+}
+std::string HybridSshTunnel::getHostKeyFingerprint() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HostKeyFingerprint(_s);
+  return rt::stdString(_s);
+}
+bool HybridSshTunnel::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridSshTunnel::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+bool HybridSshTunnel::getPreferIpv6() {
+  this->beginCall();
+  return this->ck().get_PreferIpv6();
+}
+void HybridSshTunnel::setPreferIpv6(bool value) {
+  this->beginCall();
+  this->ck().put_PreferIpv6(value);
+}
+std::string HybridSshTunnel::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+std::string HybridSshTunnel::getClientIdentifier() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ClientIdentifier(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setClientIdentifier(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "clientIdentifier");
+  this->ck().put_ClientIdentifier(value.c_str());
+}
+std::string HybridSshTunnel::getClientLogDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ClientLogDir(_s);
+  return rt::stdString(_s);
+}
+void HybridSshTunnel::setClientLogDir(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "clientLogDir");
+  this->ck().put_ClientLogDir(value.c_str());
+}
+bool HybridSshTunnel::getEnableSecrets() {
+  this->beginCall();
+  return this->ck().get_EnableSecrets();
+}
+void HybridSshTunnel::setEnableSecrets(bool value) {
+  this->beginCall();
+  this->ck().put_EnableSecrets(value);
+}
+
+// ---- Methods ----
+
+void HybridSshTunnel::authenticatePk(const std::string& username, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  authenticatePk_impl(username, privateKey);
+}
+void HybridSshTunnel::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>> HybridSshTunnel::authenticatePkAsync(const std::string& username, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSshTunnel>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(privateKey);
+  return rt::runAsync<void>("SshTunnel.authenticatePkAsync", std::move(_parts), [_self, username, privateKey]() {
+    _self->authenticatePk_impl(username, privateKey);
+  });
+}
+
+void HybridSshTunnel::authenticatePw(const std::string& login, const std::string& password) {
+  this->beginCall();
+  authenticatePw_impl(login, password);
+}
+void HybridSshTunnel::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>> HybridSshTunnel::authenticatePwAsync(const std::string& login, const std::string& password) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSshTunnel>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SshTunnel.authenticatePwAsync", std::move(_parts), [_self, login, password]() {
+    _self->authenticatePw_impl(login, password);
+  });
+}
+
+void HybridSshTunnel::authenticatePwPk(const std::string& username, const std::string& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  authenticatePwPk_impl(username, password, privateKey);
+}
+void HybridSshTunnel::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>> HybridSshTunnel::authenticatePwPkAsync(const std::string& username, const std::string& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSshTunnel>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(privateKey);
+  return rt::runAsync<void>("SshTunnel.authenticatePwPkAsync", std::move(_parts), [_self, username, password, privateKey]() {
+    _self->authenticatePwPk_impl(username, password, privateKey);
+  });
+}
+
+void HybridSshTunnel::beginAccepting(double listenPort) {
+  this->beginCall();
+  beginAccepting_impl(listenPort);
+}
+void HybridSshTunnel::beginAccepting_impl(double listenPort) {
+  if (!this->ck().BeginAccepting(rt::toInt(listenPort, "listenPort"))) throw this->fail("beginAccepting");
+}
+std::shared_ptr<Promise<void>> HybridSshTunnel::beginAcceptingAsync(double listenPort) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSshTunnel>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SshTunnel.beginAcceptingAsync", std::move(_parts), [_self, listenPort]() {
+    _self->beginAccepting_impl(listenPort);
+  });
+}
+
+void HybridSshTunnel::closeTunnel(bool waitForThreads) {
+  this->beginCall();
+  closeTunnel_impl(waitForThreads);
+}
+void HybridSshTunnel::closeTunnel_impl(bool waitForThreads) {
+  if (!this->ck().CloseTunnel(waitForThreads)) throw this->fail("closeTunnel");
+}
+
+void HybridSshTunnel::connect(const std::string& hostname, double port) {
+  this->beginCall();
+  connect_impl(hostname, port);
+}
+void HybridSshTunnel::connect_impl(const std::string& hostname, double port) {
+  rt::checkNoNul(hostname, "hostname");
+  if (!this->ck().Connect(hostname.c_str(), rt::toInt(port, "port"))) throw this->fail("connect");
+}
+std::shared_ptr<Promise<void>> HybridSshTunnel::connectAsync(const std::string& hostname, double port) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSshTunnel>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("SshTunnel.connectAsync", std::move(_parts), [_self, hostname, port]() {
+    _self->connect_impl(hostname, port);
+  });
+}
+
+void HybridSshTunnel::disconnectAllClients(bool waitForThreads) {
+  this->beginCall();
+  disconnectAllClients_impl(waitForThreads);
+}
+void HybridSshTunnel::disconnectAllClients_impl(bool waitForThreads) {
+  if (!this->ck().DisconnectAllClients(waitForThreads)) throw this->fail("disconnectAllClients");
+}
+
+void HybridSshTunnel::stopAccepting(bool waitForThread) {
+  this->beginCall();
+  stopAccepting_impl(waitForThread);
+}
+void HybridSshTunnel::stopAccepting_impl(bool waitForThread) {
+  if (!this->ck().StopAccepting(waitForThread)) throw this->fail("stopAccepting");
+}
+
+void HybridSshTunnel::connectThroughSsh(const std::shared_ptr<HybridSshSpec>& ssh, const std::string& hostname, double port) {
+  this->beginCall();
+  connectThroughSsh_impl(ssh, hostname, port);
+}
+void HybridSshTunnel::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>> HybridSshTunnel::connectThroughSshAsync(const std::shared_ptr<HybridSshSpec>& ssh, const std::string& hostname, double port) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSshTunnel>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(ssh);
+  return rt::runAsync<void>("SshTunnel.connectThroughSshAsync", std::move(_parts), [_self, ssh, hostname, port]() {
+    _self->connectThroughSsh_impl(ssh, hostname, port);
+  });
+}
+
+bool HybridSshTunnel::isSshConnected() {
+  this->beginCall();
+  return isSshConnected_impl();
+}
+bool HybridSshTunnel::isSshConnected_impl() {
+  return this->ck().IsSshConnected();
+}
+
+std::string HybridSshTunnel::getCurrentState() {
+  this->beginCall();
+  return getCurrentState_impl();
+}
+std::string HybridSshTunnel::getCurrentState_impl() {
+  CkString _out;
+  if (!this->ck().GetCurrentState(_out)) throw this->fail("getCurrentState");
+  return rt::stdString(_out);
+}
+
+void HybridSshTunnel::authenticateSecPw(const std::shared_ptr<HybridSecureStringSpec>& login, const std::shared_ptr<HybridSecureStringSpec>& password) {
+  this->beginCall();
+  authenticateSecPw_impl(login, password);
+}
+void HybridSshTunnel::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>> HybridSshTunnel::authenticateSecPwAsync(const std::shared_ptr<HybridSecureStringSpec>& login, const std::shared_ptr<HybridSecureStringSpec>& password) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSshTunnel>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(login);
+  _parts.push_back(password);
+  return rt::runAsync<void>("SshTunnel.authenticateSecPwAsync", std::move(_parts), [_self, login, password]() {
+    _self->authenticateSecPw_impl(login, password);
+  });
+}
+
+void HybridSshTunnel::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 HybridSshTunnel::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>> HybridSshTunnel::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<HybridSshTunnel>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(username);
+  _parts.push_back(password);
+  _parts.push_back(privateKey);
+  return rt::runAsync<void>("SshTunnel.authenticateSecPwPkAsync", std::move(_parts), [_self, username, password, privateKey]() {
+    _self->authenticateSecPwPk_impl(username, password, privateKey);
+  });
+}
+
+std::string HybridSshTunnel::startKeyboardAuth(const std::string& login) {
+  this->beginCall();
+  return startKeyboardAuth_impl(login);
+}
+std::string HybridSshTunnel::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>> HybridSshTunnel::startKeyboardAuthAsync(const std::string& login) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSshTunnel>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SshTunnel.startKeyboardAuthAsync", std::move(_parts), [_self, login]() {
+    return _self->startKeyboardAuth_impl(login);
+  });
+}
+
+std::string HybridSshTunnel::continueKeyboardAuth(const std::string& response) {
+  this->beginCall();
+  return continueKeyboardAuth_impl(response);
+}
+std::string HybridSshTunnel::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>> HybridSshTunnel::continueKeyboardAuthAsync(const std::string& response) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSshTunnel>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("SshTunnel.continueKeyboardAuthAsync", std::move(_parts), [_self, response]() {
+    return _self->continueKeyboardAuth_impl(response);
+  });
+}
+
+void HybridSshTunnel::setAllowedAlgorithms(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  setAllowedAlgorithms_impl(json);
+}
+void HybridSshTunnel::setAllowedAlgorithms_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().SetAllowedAlgorithms(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("setAllowedAlgorithms");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridSshTunnel::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridSshTunnel::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridSshTunnel::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridSshTunnel::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridSshTunnel::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat