@chilkat/react-native 11.6.1

package/cpp/HybridSocket.cpp

@@ -0,0 +1,1567 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridSocket.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCert.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridSsh.hpp"
+#include "HybridSshKey.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridSocket::HybridSocket()
+    : HybridObject(HybridSocketSpec::TAG), ChilkatObject<CkSocket>("Socket", CkSocket::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridSocket::HybridSocket(CkSocket* owned)
+    : HybridObject(HybridSocketSpec::TAG), ChilkatObject<CkSocket>("Socket", owned) {
+  init();
+}
+
+void HybridSocket::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridSocket::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridSocket::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSocket::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSocket::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSocket::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSocket::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridSocket::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridSocket::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridSocket::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridSocket::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridSocket::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridSocket::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+double HybridSocket::getAcceptFailReason() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_AcceptFailReason());
+}
+double HybridSocket::getBandwidthThrottleDown() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_BandwidthThrottleDown());
+}
+void HybridSocket::setBandwidthThrottleDown(double value) {
+  this->beginCall();
+  this->ck().put_BandwidthThrottleDown(rt::toInt(value, "bandwidthThrottleDown"));
+}
+double HybridSocket::getBandwidthThrottleUp() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_BandwidthThrottleUp());
+}
+void HybridSocket::setBandwidthThrottleUp(double value) {
+  this->beginCall();
+  this->ck().put_BandwidthThrottleUp(rt::toInt(value, "bandwidthThrottleUp"));
+}
+bool HybridSocket::getBigEndian() {
+  this->beginCall();
+  return this->ck().get_BigEndian();
+}
+void HybridSocket::setBigEndian(bool value) {
+  this->beginCall();
+  this->ck().put_BigEndian(value);
+}
+std::string HybridSocket::getClientIpAddress() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ClientIpAddress(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setClientIpAddress(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "clientIpAddress");
+  this->ck().put_ClientIpAddress(value.c_str());
+}
+double HybridSocket::getClientPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ClientPort());
+}
+void HybridSocket::setClientPort(double value) {
+  this->beginCall();
+  this->ck().put_ClientPort(rt::toInt(value, "clientPort"));
+}
+double HybridSocket::getConnectFailReason() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectFailReason());
+}
+double HybridSocket::getElapsedSeconds() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ElapsedSeconds());
+}
+double HybridSocket::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridSocket::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+std::string HybridSocket::getHttpProxyAuthMethod() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyAuthMethod(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setHttpProxyAuthMethod(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyAuthMethod");
+  this->ck().put_HttpProxyAuthMethod(value.c_str());
+}
+std::string HybridSocket::getHttpProxyDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyDomain(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setHttpProxyDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyDomain");
+  this->ck().put_HttpProxyDomain(value.c_str());
+}
+std::string HybridSocket::getHttpProxyHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setHttpProxyHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyHostname");
+  this->ck().put_HttpProxyHostname(value.c_str());
+}
+std::string HybridSocket::getHttpProxyPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setHttpProxyPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyPassword");
+  this->ck().put_HttpProxyPassword(value.c_str());
+}
+double HybridSocket::getHttpProxyPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HttpProxyPort());
+}
+void HybridSocket::setHttpProxyPort(double value) {
+  this->beginCall();
+  this->ck().put_HttpProxyPort(rt::toInt(value, "httpProxyPort"));
+}
+std::string HybridSocket::getHttpProxyUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpProxyUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setHttpProxyUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpProxyUsername");
+  this->ck().put_HttpProxyUsername(value.c_str());
+}
+bool HybridSocket::getIsConnected() {
+  this->beginCall();
+  return this->ck().get_IsConnected();
+}
+bool HybridSocket::getKeepAlive() {
+  this->beginCall();
+  return this->ck().get_KeepAlive();
+}
+void HybridSocket::setKeepAlive(bool value) {
+  this->beginCall();
+  this->ck().put_KeepAlive(value);
+}
+bool HybridSocket::getKeepSessionLog() {
+  this->beginCall();
+  return this->ck().get_KeepSessionLog();
+}
+void HybridSocket::setKeepSessionLog(bool value) {
+  this->beginCall();
+  this->ck().put_KeepSessionLog(value);
+}
+bool HybridSocket::getLastMethodFailed() {
+  this->beginCall();
+  return this->ck().get_LastMethodFailed();
+}
+std::string HybridSocket::getLocalIpAddress() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LocalIpAddress(_s);
+  return rt::stdString(_s);
+}
+double HybridSocket::getLocalPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_LocalPort());
+}
+double HybridSocket::getMaxReadIdleMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_MaxReadIdleMs());
+}
+void HybridSocket::setMaxReadIdleMs(double value) {
+  this->beginCall();
+  this->ck().put_MaxReadIdleMs(rt::toInt(value, "maxReadIdleMs"));
+}
+double HybridSocket::getMaxSendIdleMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_MaxSendIdleMs());
+}
+void HybridSocket::setMaxSendIdleMs(double value) {
+  this->beginCall();
+  this->ck().put_MaxSendIdleMs(rt::toInt(value, "maxSendIdleMs"));
+}
+std::string HybridSocket::getMyIpAddress() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_MyIpAddress(_s);
+  return rt::stdString(_s);
+}
+double HybridSocket::getNumReceivedClientCerts() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumReceivedClientCerts());
+}
+double HybridSocket::getNumSocketsInSet() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumSocketsInSet());
+}
+double HybridSocket::getNumSslAcceptableClientCAs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumSslAcceptableClientCAs());
+}
+double HybridSocket::getObjectId() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ObjectId());
+}
+double HybridSocket::getPercentDoneScale() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_PercentDoneScale());
+}
+void HybridSocket::setPercentDoneScale(double value) {
+  this->beginCall();
+  this->ck().put_PercentDoneScale(rt::toInt(value, "percentDoneScale"));
+}
+bool HybridSocket::getPreferIpv6() {
+  this->beginCall();
+  return this->ck().get_PreferIpv6();
+}
+void HybridSocket::setPreferIpv6(bool value) {
+  this->beginCall();
+  this->ck().put_PreferIpv6(value);
+}
+double HybridSocket::getReceiveFailReason() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ReceiveFailReason());
+}
+double HybridSocket::getReceivePacketSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ReceivePacketSize());
+}
+void HybridSocket::setReceivePacketSize(double value) {
+  this->beginCall();
+  this->ck().put_ReceivePacketSize(rt::toInt(value, "receivePacketSize"));
+}
+double HybridSocket::getReceivedCount() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ReceivedCount());
+}
+void HybridSocket::setReceivedCount(double value) {
+  this->beginCall();
+  this->ck().put_ReceivedCount(rt::toInt(value, "receivedCount"));
+}
+double HybridSocket::getReceivedInt() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ReceivedInt());
+}
+void HybridSocket::setReceivedInt(double value) {
+  this->beginCall();
+  this->ck().put_ReceivedInt(rt::toInt(value, "receivedInt"));
+}
+std::string HybridSocket::getRemoteIpAddress() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_RemoteIpAddress(_s);
+  return rt::stdString(_s);
+}
+double HybridSocket::getRemotePort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_RemotePort());
+}
+bool HybridSocket::getRequireSslCertVerify() {
+  this->beginCall();
+  return this->ck().get_RequireSslCertVerify();
+}
+void HybridSocket::setRequireSslCertVerify(bool value) {
+  this->beginCall();
+  this->ck().put_RequireSslCertVerify(value);
+}
+double HybridSocket::getSelectorIndex() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SelectorIndex());
+}
+void HybridSocket::setSelectorIndex(double value) {
+  this->beginCall();
+  this->ck().put_SelectorIndex(rt::toInt(value, "selectorIndex"));
+}
+double HybridSocket::getSelectorReadIndex() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SelectorReadIndex());
+}
+void HybridSocket::setSelectorReadIndex(double value) {
+  this->beginCall();
+  this->ck().put_SelectorReadIndex(rt::toInt(value, "selectorReadIndex"));
+}
+double HybridSocket::getSelectorWriteIndex() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SelectorWriteIndex());
+}
+void HybridSocket::setSelectorWriteIndex(double value) {
+  this->beginCall();
+  this->ck().put_SelectorWriteIndex(rt::toInt(value, "selectorWriteIndex"));
+}
+double HybridSocket::getSendFailReason() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SendFailReason());
+}
+double HybridSocket::getSendPacketSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SendPacketSize());
+}
+void HybridSocket::setSendPacketSize(double value) {
+  this->beginCall();
+  this->ck().put_SendPacketSize(rt::toInt(value, "sendPacketSize"));
+}
+std::string HybridSocket::getSessionLog() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SessionLog(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSocket::getSessionLogEncoding() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SessionLogEncoding(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setSessionLogEncoding(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sessionLogEncoding");
+  this->ck().put_SessionLogEncoding(value.c_str());
+}
+double HybridSocket::getSoRcvBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoRcvBuf());
+}
+void HybridSocket::setSoRcvBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoRcvBuf(rt::toInt(value, "soRcvBuf"));
+}
+bool HybridSocket::getSoReuseAddr() {
+  this->beginCall();
+  return this->ck().get_SoReuseAddr();
+}
+void HybridSocket::setSoReuseAddr(bool value) {
+  this->beginCall();
+  this->ck().put_SoReuseAddr(value);
+}
+double HybridSocket::getSoSndBuf() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SoSndBuf());
+}
+void HybridSocket::setSoSndBuf(double value) {
+  this->beginCall();
+  this->ck().put_SoSndBuf(rt::toInt(value, "soSndBuf"));
+}
+std::string HybridSocket::getSocksHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setSocksHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksHostname");
+  this->ck().put_SocksHostname(value.c_str());
+}
+std::string HybridSocket::getSocksPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setSocksPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksPassword");
+  this->ck().put_SocksPassword(value.c_str());
+}
+double HybridSocket::getSocksPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksPort());
+}
+void HybridSocket::setSocksPort(double value) {
+  this->beginCall();
+  this->ck().put_SocksPort(rt::toInt(value, "socksPort"));
+}
+std::string HybridSocket::getSocksUsername() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SocksUsername(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setSocksUsername(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "socksUsername");
+  this->ck().put_SocksUsername(value.c_str());
+}
+double HybridSocket::getSocksVersion() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SocksVersion());
+}
+void HybridSocket::setSocksVersion(double value) {
+  this->beginCall();
+  this->ck().put_SocksVersion(rt::toInt(value, "socksVersion"));
+}
+bool HybridSocket::getSsl() {
+  this->beginCall();
+  return this->ck().get_Ssl();
+}
+void HybridSocket::setSsl(bool value) {
+  this->beginCall();
+  this->ck().put_Ssl(value);
+}
+std::string HybridSocket::getSslAllowedCiphers() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SslAllowedCiphers(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setSslAllowedCiphers(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sslAllowedCiphers");
+  this->ck().put_SslAllowedCiphers(value.c_str());
+}
+std::string HybridSocket::getSslProtocol() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SslProtocol(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setSslProtocol(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sslProtocol");
+  this->ck().put_SslProtocol(value.c_str());
+}
+std::string HybridSocket::getStringCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_StringCharset(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setStringCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "stringCharset");
+  this->ck().put_StringCharset(value.c_str());
+}
+bool HybridSocket::getTcpNoDelay() {
+  this->beginCall();
+  return this->ck().get_TcpNoDelay();
+}
+void HybridSocket::setTcpNoDelay(bool value) {
+  this->beginCall();
+  this->ck().put_TcpNoDelay(value);
+}
+std::string HybridSocket::getTlsCipherSuite() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsCipherSuite(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSocket::getTlsPinSet() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsPinSet(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setTlsPinSet(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "tlsPinSet");
+  this->ck().put_TlsPinSet(value.c_str());
+}
+std::string HybridSocket::getTlsVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TlsVersion(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSocket::getUserData() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UserData(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setUserData(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "userData");
+  this->ck().put_UserData(value.c_str());
+}
+double HybridSocket::getListenPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ListenPort());
+}
+bool HybridSocket::getHttpProxyForHttp() {
+  this->beginCall();
+  return this->ck().get_HttpProxyForHttp();
+}
+void HybridSocket::setHttpProxyForHttp(bool value) {
+  this->beginCall();
+  this->ck().put_HttpProxyForHttp(value);
+}
+double HybridSocket::getRcvBytesPerSec() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_RcvBytesPerSec());
+}
+double HybridSocket::getSendBytesPerSec() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SendBytesPerSec());
+}
+std::string HybridSocket::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+std::string HybridSocket::getAlpnProtocol() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AlpnProtocol(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setAlpnProtocol(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "alpnProtocol");
+  this->ck().put_AlpnProtocol(value.c_str());
+}
+std::string HybridSocket::getSniHostname() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SniHostname(_s);
+  return rt::stdString(_s);
+}
+void HybridSocket::setSniHostname(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sniHostname");
+  this->ck().put_SniHostname(value.c_str());
+}
+double HybridSocket::getNumBytesAvailable() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumBytesAvailable());
+}
+
+// ---- Methods ----
+
+void HybridSocket::addSslAcceptableClientCaDn(const std::string& certAuthDN) {
+  this->beginCall();
+  addSslAcceptableClientCaDn_impl(certAuthDN);
+}
+void HybridSocket::addSslAcceptableClientCaDn_impl(const std::string& certAuthDN) {
+  rt::checkNoNul(certAuthDN, "certAuthDN");
+  if (!this->ck().AddSslAcceptableClientCaDn(certAuthDN.c_str())) throw this->fail("addSslAcceptableClientCaDn");
+}
+
+void HybridSocket::bindAndListen(double port, double backLog) {
+  this->beginCall();
+  bindAndListen_impl(port, backLog);
+}
+void HybridSocket::bindAndListen_impl(double port, double backLog) {
+  if (!this->ck().BindAndListen(rt::toInt(port, "port"), rt::toInt(backLog, "backLog"))) throw this->fail("bindAndListen");
+}
+std::shared_ptr<Promise<void>> HybridSocket::bindAndListenAsync(double port, double backLog) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.bindAndListenAsync", std::move(_parts), [_self, port, backLog]() {
+    _self->bindAndListen_impl(port, backLog);
+  });
+}
+
+std::string HybridSocket::buildHttpGetRequest(const std::string& url) {
+  this->beginCall();
+  return buildHttpGetRequest_impl(url);
+}
+std::string HybridSocket::buildHttpGetRequest_impl(const std::string& url) {
+  rt::checkNoNul(url, "url");
+  CkString _out;
+  if (!this->ck().BuildHttpGetRequest(url.c_str(), _out)) throw this->fail("buildHttpGetRequest");
+  return rt::stdString(_out);
+}
+
+double HybridSocket::checkWriteable(double maxWaitMs) {
+  this->beginCall();
+  return checkWriteable_impl(maxWaitMs);
+}
+double HybridSocket::checkWriteable_impl(double maxWaitMs) {
+  return static_cast<double>(this->ck().CheckWriteable(rt::toInt(maxWaitMs, "maxWaitMs")));
+}
+std::shared_ptr<Promise<double>> HybridSocket::checkWriteableAsync(double maxWaitMs) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Socket.checkWriteableAsync", std::move(_parts), [_self, maxWaitMs]() {
+    return _self->checkWriteable_impl(maxWaitMs);
+  });
+}
+
+void HybridSocket::clearSessionLog() {
+  this->beginCall();
+  clearSessionLog_impl();
+}
+void HybridSocket::clearSessionLog_impl() {
+  this->ck().ClearSessionLog();
+}
+
+void HybridSocket::close(double maxWaitMs) {
+  this->beginCall();
+  close_impl(maxWaitMs);
+}
+void HybridSocket::close_impl(double maxWaitMs) {
+  if (!this->ck().Close(rt::toInt(maxWaitMs, "maxWaitMs"))) throw this->fail("close");
+}
+std::shared_ptr<Promise<void>> HybridSocket::closeAsync(double maxWaitMs) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.closeAsync", std::move(_parts), [_self, maxWaitMs]() {
+    _self->close_impl(maxWaitMs);
+  });
+}
+
+void HybridSocket::connect(const std::string& hostname, double port, bool ssl, double maxWaitMs) {
+  this->beginCall();
+  connect_impl(hostname, port, ssl, maxWaitMs);
+}
+void HybridSocket::connect_impl(const std::string& hostname, double port, bool ssl, double maxWaitMs) {
+  rt::checkNoNul(hostname, "hostname");
+  if (!this->ck().Connect(hostname.c_str(), rt::toInt(port, "port"), ssl, rt::toInt(maxWaitMs, "maxWaitMs"))) throw this->fail("connect");
+}
+std::shared_ptr<Promise<void>> HybridSocket::connectAsync(const std::string& hostname, double port, bool ssl, double maxWaitMs) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.connectAsync", std::move(_parts), [_self, hostname, port, ssl, maxWaitMs]() {
+    _self->connect_impl(hostname, port, ssl, maxWaitMs);
+  });
+}
+
+void HybridSocket::convertFromSsl() {
+  this->beginCall();
+  convertFromSsl_impl();
+}
+void HybridSocket::convertFromSsl_impl() {
+  if (!this->ck().ConvertFromSsl()) throw this->fail("convertFromSsl");
+}
+std::shared_ptr<Promise<void>> HybridSocket::convertFromSslAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.convertFromSslAsync", std::move(_parts), [_self]() {
+    _self->convertFromSsl_impl();
+  });
+}
+
+void HybridSocket::convertToSsl() {
+  this->beginCall();
+  convertToSsl_impl();
+}
+void HybridSocket::convertToSsl_impl() {
+  if (!this->ck().ConvertToSsl()) throw this->fail("convertToSsl");
+}
+std::shared_ptr<Promise<void>> HybridSocket::convertToSslAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.convertToSslAsync", std::move(_parts), [_self]() {
+    _self->convertToSsl_impl();
+  });
+}
+
+void HybridSocket::dnsCacheClear() {
+  this->beginCall();
+  dnsCacheClear_impl();
+}
+void HybridSocket::dnsCacheClear_impl() {
+  this->ck().DnsCacheClear();
+}
+
+std::string HybridSocket::dnsLookup(const std::string& hostname, double maxWaitMs) {
+  this->beginCall();
+  return dnsLookup_impl(hostname, maxWaitMs);
+}
+std::string HybridSocket::dnsLookup_impl(const std::string& hostname, double maxWaitMs) {
+  rt::checkNoNul(hostname, "hostname");
+  CkString _out;
+  if (!this->ck().DnsLookup(hostname.c_str(), rt::toInt(maxWaitMs, "maxWaitMs"), _out)) throw this->fail("dnsLookup");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSocket::dnsLookupAsync(const std::string& hostname, double maxWaitMs) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Socket.dnsLookupAsync", std::move(_parts), [_self, hostname, maxWaitMs]() {
+    return _self->dnsLookup_impl(hostname, maxWaitMs);
+  });
+}
+
+std::string HybridSocket::getSslAcceptableClientCaDn(double index) {
+  this->beginCall();
+  return getSslAcceptableClientCaDn_impl(index);
+}
+std::string HybridSocket::getSslAcceptableClientCaDn_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetSslAcceptableClientCaDn(rt::toInt(index, "index"), _out)) throw this->fail("getSslAcceptableClientCaDn");
+  return rt::stdString(_out);
+}
+
+void HybridSocket::initSslServer(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  initSslServer_impl(cert);
+}
+void HybridSocket::initSslServer_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().InitSslServer(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("initSslServer");
+}
+
+bool HybridSocket::pollDataAvailable() {
+  this->beginCall();
+  return pollDataAvailable_impl();
+}
+bool HybridSocket::pollDataAvailable_impl() {
+  return this->ck().PollDataAvailable();
+}
+std::shared_ptr<Promise<bool>> HybridSocket::pollDataAvailableAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<bool>("Socket.pollDataAvailableAsync", std::move(_parts), [_self]() {
+    return _self->pollDataAvailable_impl();
+  });
+}
+
+void HybridSocket::receiveByte(bool bUnsigned) {
+  this->beginCall();
+  receiveByte_impl(bUnsigned);
+}
+void HybridSocket::receiveByte_impl(bool bUnsigned) {
+  if (!this->ck().ReceiveByte(bUnsigned)) throw this->fail("receiveByte");
+}
+std::shared_ptr<Promise<void>> HybridSocket::receiveByteAsync(bool bUnsigned) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.receiveByteAsync", std::move(_parts), [_self, bUnsigned]() {
+    _self->receiveByte_impl(bUnsigned);
+  });
+}
+
+std::string HybridSocket::receiveBytesENC(const std::string& encodingAlg) {
+  this->beginCall();
+  return receiveBytesENC_impl(encodingAlg);
+}
+std::string HybridSocket::receiveBytesENC_impl(const std::string& encodingAlg) {
+  rt::checkNoNul(encodingAlg, "encodingAlg");
+  CkString _out;
+  if (!this->ck().ReceiveBytesENC(encodingAlg.c_str(), _out)) throw this->fail("receiveBytesENC");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSocket::receiveBytesENCAsync(const std::string& encodingAlg) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Socket.receiveBytesENCAsync", std::move(_parts), [_self, encodingAlg]() {
+    return _self->receiveBytesENC_impl(encodingAlg);
+  });
+}
+
+void HybridSocket::receiveBytesToFile(const std::string& appendFilename) {
+  this->beginCall();
+  receiveBytesToFile_impl(appendFilename);
+}
+void HybridSocket::receiveBytesToFile_impl(const std::string& appendFilename) {
+  rt::checkNoNul(appendFilename, "appendFilename");
+  if (!this->ck().ReceiveBytesToFile(appendFilename.c_str())) throw this->fail("receiveBytesToFile");
+}
+std::shared_ptr<Promise<void>> HybridSocket::receiveBytesToFileAsync(const std::string& appendFilename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.receiveBytesToFileAsync", std::move(_parts), [_self, appendFilename]() {
+    _self->receiveBytesToFile_impl(appendFilename);
+  });
+}
+
+double HybridSocket::receiveCount() {
+  this->beginCall();
+  return receiveCount_impl();
+}
+double HybridSocket::receiveCount_impl() {
+  return static_cast<double>(this->ck().ReceiveCount());
+}
+std::shared_ptr<Promise<double>> HybridSocket::receiveCountAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Socket.receiveCountAsync", std::move(_parts), [_self]() {
+    return _self->receiveCount_impl();
+  });
+}
+
+void HybridSocket::receiveInt16(bool bigEndian, bool bUnsigned) {
+  this->beginCall();
+  receiveInt16_impl(bigEndian, bUnsigned);
+}
+void HybridSocket::receiveInt16_impl(bool bigEndian, bool bUnsigned) {
+  if (!this->ck().ReceiveInt16(bigEndian, bUnsigned)) throw this->fail("receiveInt16");
+}
+std::shared_ptr<Promise<void>> HybridSocket::receiveInt16Async(bool bigEndian, bool bUnsigned) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.receiveInt16Async", std::move(_parts), [_self, bigEndian, bUnsigned]() {
+    _self->receiveInt16_impl(bigEndian, bUnsigned);
+  });
+}
+
+void HybridSocket::receiveInt32(bool bigEndian) {
+  this->beginCall();
+  receiveInt32_impl(bigEndian);
+}
+void HybridSocket::receiveInt32_impl(bool bigEndian) {
+  if (!this->ck().ReceiveInt32(bigEndian)) throw this->fail("receiveInt32");
+}
+std::shared_ptr<Promise<void>> HybridSocket::receiveInt32Async(bool bigEndian) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.receiveInt32Async", std::move(_parts), [_self, bigEndian]() {
+    _self->receiveInt32_impl(bigEndian);
+  });
+}
+
+std::string HybridSocket::receiveNBytesENC(double numBytes, const std::string& encodingAlg) {
+  this->beginCall();
+  return receiveNBytesENC_impl(numBytes, encodingAlg);
+}
+std::string HybridSocket::receiveNBytesENC_impl(double numBytes, const std::string& encodingAlg) {
+  rt::checkNoNul(encodingAlg, "encodingAlg");
+  CkString _out;
+  if (!this->ck().ReceiveNBytesENC(rt::toULong(numBytes, "numBytes"), encodingAlg.c_str(), _out)) throw this->fail("receiveNBytesENC");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSocket::receiveNBytesENCAsync(double numBytes, const std::string& encodingAlg) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Socket.receiveNBytesENCAsync", std::move(_parts), [_self, numBytes, encodingAlg]() {
+    return _self->receiveNBytesENC_impl(numBytes, encodingAlg);
+  });
+}
+
+std::string HybridSocket::receiveString() {
+  this->beginCall();
+  return receiveString_impl();
+}
+std::string HybridSocket::receiveString_impl() {
+  CkString _out;
+  if (!this->ck().ReceiveString(_out)) throw this->fail("receiveString");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSocket::receiveStringAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Socket.receiveStringAsync", std::move(_parts), [_self]() {
+    return _self->receiveString_impl();
+  });
+}
+
+std::string HybridSocket::receiveStringMaxN(double maxByteCount) {
+  this->beginCall();
+  return receiveStringMaxN_impl(maxByteCount);
+}
+std::string HybridSocket::receiveStringMaxN_impl(double maxByteCount) {
+  CkString _out;
+  if (!this->ck().ReceiveStringMaxN(rt::toInt(maxByteCount, "maxByteCount"), _out)) throw this->fail("receiveStringMaxN");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSocket::receiveStringMaxNAsync(double maxByteCount) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Socket.receiveStringMaxNAsync", std::move(_parts), [_self, maxByteCount]() {
+    return _self->receiveStringMaxN_impl(maxByteCount);
+  });
+}
+
+std::string HybridSocket::receiveStringUntilByte(double lookForByte) {
+  this->beginCall();
+  return receiveStringUntilByte_impl(lookForByte);
+}
+std::string HybridSocket::receiveStringUntilByte_impl(double lookForByte) {
+  CkString _out;
+  if (!this->ck().ReceiveStringUntilByte(rt::toInt(lookForByte, "lookForByte"), _out)) throw this->fail("receiveStringUntilByte");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSocket::receiveStringUntilByteAsync(double lookForByte) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Socket.receiveStringUntilByteAsync", std::move(_parts), [_self, lookForByte]() {
+    return _self->receiveStringUntilByte_impl(lookForByte);
+  });
+}
+
+std::string HybridSocket::receiveToCRLF() {
+  this->beginCall();
+  return receiveToCRLF_impl();
+}
+std::string HybridSocket::receiveToCRLF_impl() {
+  CkString _out;
+  if (!this->ck().ReceiveToCRLF(_out)) throw this->fail("receiveToCRLF");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSocket::receiveToCRLFAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Socket.receiveToCRLFAsync", std::move(_parts), [_self]() {
+    return _self->receiveToCRLF_impl();
+  });
+}
+
+std::string HybridSocket::receiveUntilMatch(const std::string& matchStr) {
+  this->beginCall();
+  return receiveUntilMatch_impl(matchStr);
+}
+std::string HybridSocket::receiveUntilMatch_impl(const std::string& matchStr) {
+  rt::checkNoNul(matchStr, "matchStr");
+  CkString _out;
+  if (!this->ck().ReceiveUntilMatch(matchStr.c_str(), _out)) throw this->fail("receiveUntilMatch");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSocket::receiveUntilMatchAsync(const std::string& matchStr) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Socket.receiveUntilMatchAsync", std::move(_parts), [_self, matchStr]() {
+    return _self->receiveUntilMatch_impl(matchStr);
+  });
+}
+
+double HybridSocket::selectForReading(double timeoutMs) {
+  this->beginCall();
+  return selectForReading_impl(timeoutMs);
+}
+double HybridSocket::selectForReading_impl(double timeoutMs) {
+  return static_cast<double>(this->ck().SelectForReading(rt::toInt(timeoutMs, "timeoutMs")));
+}
+std::shared_ptr<Promise<double>> HybridSocket::selectForReadingAsync(double timeoutMs) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Socket.selectForReadingAsync", std::move(_parts), [_self, timeoutMs]() {
+    return _self->selectForReading_impl(timeoutMs);
+  });
+}
+
+double HybridSocket::selectForWriting(double timeoutMs) {
+  this->beginCall();
+  return selectForWriting_impl(timeoutMs);
+}
+double HybridSocket::selectForWriting_impl(double timeoutMs) {
+  return static_cast<double>(this->ck().SelectForWriting(rt::toInt(timeoutMs, "timeoutMs")));
+}
+std::shared_ptr<Promise<double>> HybridSocket::selectForWritingAsync(double timeoutMs) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Socket.selectForWritingAsync", std::move(_parts), [_self, timeoutMs]() {
+    return _self->selectForWriting_impl(timeoutMs);
+  });
+}
+
+void HybridSocket::sendByte(double value) {
+  this->beginCall();
+  sendByte_impl(value);
+}
+void HybridSocket::sendByte_impl(double value) {
+  if (!this->ck().SendByte(rt::toInt(value, "value"))) throw this->fail("sendByte");
+}
+std::shared_ptr<Promise<void>> HybridSocket::sendByteAsync(double value) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.sendByteAsync", std::move(_parts), [_self, value]() {
+    _self->sendByte_impl(value);
+  });
+}
+
+void HybridSocket::sendBytesENC(const std::string& encodedBytes, const std::string& encodingAlg) {
+  this->beginCall();
+  sendBytesENC_impl(encodedBytes, encodingAlg);
+}
+void HybridSocket::sendBytesENC_impl(const std::string& encodedBytes, const std::string& encodingAlg) {
+  rt::checkNoNul(encodedBytes, "encodedBytes");
+  rt::checkNoNul(encodingAlg, "encodingAlg");
+  if (!this->ck().SendBytesENC(encodedBytes.c_str(), encodingAlg.c_str())) throw this->fail("sendBytesENC");
+}
+std::shared_ptr<Promise<void>> HybridSocket::sendBytesENCAsync(const std::string& encodedBytes, const std::string& encodingAlg) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.sendBytesENCAsync", std::move(_parts), [_self, encodedBytes, encodingAlg]() {
+    _self->sendBytesENC_impl(encodedBytes, encodingAlg);
+  });
+}
+
+void HybridSocket::sendCount(double byteCount) {
+  this->beginCall();
+  sendCount_impl(byteCount);
+}
+void HybridSocket::sendCount_impl(double byteCount) {
+  if (!this->ck().SendCount(rt::toInt(byteCount, "byteCount"))) throw this->fail("sendCount");
+}
+std::shared_ptr<Promise<void>> HybridSocket::sendCountAsync(double byteCount) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.sendCountAsync", std::move(_parts), [_self, byteCount]() {
+    _self->sendCount_impl(byteCount);
+  });
+}
+
+void HybridSocket::sendInt16(double value, bool bigEndian) {
+  this->beginCall();
+  sendInt16_impl(value, bigEndian);
+}
+void HybridSocket::sendInt16_impl(double value, bool bigEndian) {
+  if (!this->ck().SendInt16(rt::toInt(value, "value"), bigEndian)) throw this->fail("sendInt16");
+}
+std::shared_ptr<Promise<void>> HybridSocket::sendInt16Async(double value, bool bigEndian) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.sendInt16Async", std::move(_parts), [_self, value, bigEndian]() {
+    _self->sendInt16_impl(value, bigEndian);
+  });
+}
+
+void HybridSocket::sendInt32(double value, bool bigEndian) {
+  this->beginCall();
+  sendInt32_impl(value, bigEndian);
+}
+void HybridSocket::sendInt32_impl(double value, bool bigEndian) {
+  if (!this->ck().SendInt32(rt::toInt(value, "value"), bigEndian)) throw this->fail("sendInt32");
+}
+std::shared_ptr<Promise<void>> HybridSocket::sendInt32Async(double value, bool bigEndian) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.sendInt32Async", std::move(_parts), [_self, value, bigEndian]() {
+    _self->sendInt32_impl(value, bigEndian);
+  });
+}
+
+void HybridSocket::sendString(const std::string& stringToSend) {
+  this->beginCall();
+  sendString_impl(stringToSend);
+}
+void HybridSocket::sendString_impl(const std::string& stringToSend) {
+  rt::checkNoNul(stringToSend, "stringToSend");
+  if (!this->ck().SendString(stringToSend.c_str())) throw this->fail("sendString");
+}
+std::shared_ptr<Promise<void>> HybridSocket::sendStringAsync(const std::string& stringToSend) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.sendStringAsync", std::move(_parts), [_self, stringToSend]() {
+    _self->sendString_impl(stringToSend);
+  });
+}
+
+void HybridSocket::setSslClientCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setSslClientCert_impl(cert);
+}
+void HybridSocket::setSslClientCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetSslClientCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setSslClientCert");
+}
+
+void HybridSocket::setSslClientCertPem(const std::string& pemDataOrFilename, const std::string& pemPassword) {
+  this->beginCall();
+  setSslClientCertPem_impl(pemDataOrFilename, pemPassword);
+}
+void HybridSocket::setSslClientCertPem_impl(const std::string& pemDataOrFilename, const std::string& pemPassword) {
+  rt::checkNoNul(pemDataOrFilename, "pemDataOrFilename");
+  rt::checkNoNul(pemPassword, "pemPassword");
+  if (!this->ck().SetSslClientCertPem(pemDataOrFilename.c_str(), pemPassword.c_str())) throw this->fail("setSslClientCertPem");
+}
+
+void HybridSocket::setSslClientCertPfx(const std::string& pfxFilename, const std::string& pfxPassword) {
+  this->beginCall();
+  setSslClientCertPfx_impl(pfxFilename, pfxPassword);
+}
+void HybridSocket::setSslClientCertPfx_impl(const std::string& pfxFilename, const std::string& pfxPassword) {
+  rt::checkNoNul(pfxFilename, "pfxFilename");
+  rt::checkNoNul(pfxPassword, "pfxPassword");
+  if (!this->ck().SetSslClientCertPfx(pfxFilename.c_str(), pfxPassword.c_str())) throw this->fail("setSslClientCertPfx");
+}
+
+void HybridSocket::sleepMs(double millisec) {
+  this->beginCall();
+  sleepMs_impl(millisec);
+}
+void HybridSocket::sleepMs_impl(double millisec) {
+  this->ck().SleepMs(rt::toInt(millisec, "millisec"));
+}
+
+void HybridSocket::sshAuthenticatePk(const std::string& sshLogin, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  sshAuthenticatePk_impl(sshLogin, privateKey);
+}
+void HybridSocket::sshAuthenticatePk_impl(const std::string& sshLogin, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  rt::checkNoNul(sshLogin, "sshLogin");
+  if (!this->ck().SshAuthenticatePk(sshLogin.c_str(), rt::implOf<HybridSshKey>(privateKey, "privateKey").ck())) throw this->fail("sshAuthenticatePk");
+}
+std::shared_ptr<Promise<void>> HybridSocket::sshAuthenticatePkAsync(const std::string& sshLogin, const std::shared_ptr<HybridSshKeySpec>& privateKey) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(privateKey);
+  return rt::runAsync<void>("Socket.sshAuthenticatePkAsync", std::move(_parts), [_self, sshLogin, privateKey]() {
+    _self->sshAuthenticatePk_impl(sshLogin, privateKey);
+  });
+}
+
+void HybridSocket::sshAuthenticatePw(const std::string& sshLogin, const std::string& sshPassword) {
+  this->beginCall();
+  sshAuthenticatePw_impl(sshLogin, sshPassword);
+}
+void HybridSocket::sshAuthenticatePw_impl(const std::string& sshLogin, const std::string& sshPassword) {
+  rt::checkNoNul(sshLogin, "sshLogin");
+  rt::checkNoNul(sshPassword, "sshPassword");
+  if (!this->ck().SshAuthenticatePw(sshLogin.c_str(), sshPassword.c_str())) throw this->fail("sshAuthenticatePw");
+}
+std::shared_ptr<Promise<void>> HybridSocket::sshAuthenticatePwAsync(const std::string& sshLogin, const std::string& sshPassword) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.sshAuthenticatePwAsync", std::move(_parts), [_self, sshLogin, sshPassword]() {
+    _self->sshAuthenticatePw_impl(sshLogin, sshPassword);
+  });
+}
+
+void HybridSocket::sshCloseTunnel() {
+  this->beginCall();
+  sshCloseTunnel_impl();
+}
+void HybridSocket::sshCloseTunnel_impl() {
+  if (!this->ck().SshCloseTunnel()) throw this->fail("sshCloseTunnel");
+}
+std::shared_ptr<Promise<void>> HybridSocket::sshCloseTunnelAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.sshCloseTunnelAsync", std::move(_parts), [_self]() {
+    _self->sshCloseTunnel_impl();
+  });
+}
+
+void HybridSocket::sshOpenTunnel(const std::string& sshHostname, double sshPort) {
+  this->beginCall();
+  sshOpenTunnel_impl(sshHostname, sshPort);
+}
+void HybridSocket::sshOpenTunnel_impl(const std::string& sshHostname, double sshPort) {
+  rt::checkNoNul(sshHostname, "sshHostname");
+  if (!this->ck().SshOpenTunnel(sshHostname.c_str(), rt::toInt(sshPort, "sshPort"))) throw this->fail("sshOpenTunnel");
+}
+std::shared_ptr<Promise<void>> HybridSocket::sshOpenTunnelAsync(const std::string& sshHostname, double sshPort) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.sshOpenTunnelAsync", std::move(_parts), [_self, sshHostname, sshPort]() {
+    _self->sshOpenTunnel_impl(sshHostname, sshPort);
+  });
+}
+
+void HybridSocket::startTiming() {
+  this->beginCall();
+  startTiming_impl();
+}
+void HybridSocket::startTiming_impl() {
+  this->ck().StartTiming();
+}
+
+void HybridSocket::takeSocket(const std::shared_ptr<HybridSocketSpec>& sock) {
+  this->beginCall();
+  takeSocket_impl(sock);
+}
+void HybridSocket::takeSocket_impl(const std::shared_ptr<HybridSocketSpec>& sock) {
+  if (!this->ck().TakeSocket(rt::implOf<HybridSocket>(sock, "sock").ck())) throw this->fail("takeSocket");
+}
+
+void HybridSocket::tlsRenegotiate() {
+  this->beginCall();
+  tlsRenegotiate_impl();
+}
+void HybridSocket::tlsRenegotiate_impl() {
+  if (!this->ck().TlsRenegotiate()) throw this->fail("tlsRenegotiate");
+}
+std::shared_ptr<Promise<void>> HybridSocket::tlsRenegotiateAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Socket.tlsRenegotiateAsync", std::move(_parts), [_self]() {
+    _self->tlsRenegotiate_impl();
+  });
+}
+
+void HybridSocket::useSsh(const std::shared_ptr<HybridSshSpec>& ssh) {
+  this->beginCall();
+  useSsh_impl(ssh);
+}
+void HybridSocket::useSsh_impl(const std::shared_ptr<HybridSshSpec>& ssh) {
+  if (!this->ck().UseSsh(rt::implOf<HybridSsh>(ssh, "ssh").ck())) throw this->fail("useSsh");
+}
+
+void HybridSocket::receiveBd(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  receiveBd_impl(binData);
+}
+void HybridSocket::receiveBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().ReceiveBd(rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("receiveBd");
+}
+std::shared_ptr<Promise<void>> HybridSocket::receiveBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  return rt::runAsync<void>("Socket.receiveBdAsync", std::move(_parts), [_self, binData]() {
+    _self->receiveBd_impl(binData);
+  });
+}
+
+void HybridSocket::receiveSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  receiveSb_impl(sb);
+}
+void HybridSocket::receiveSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().ReceiveSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("receiveSb");
+}
+std::shared_ptr<Promise<void>> HybridSocket::receiveSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<void>("Socket.receiveSbAsync", std::move(_parts), [_self, sb]() {
+    _self->receiveSb_impl(sb);
+  });
+}
+
+void HybridSocket::sendBd(const std::shared_ptr<HybridBinDataSpec>& binData, double offset, double numBytes) {
+  this->beginCall();
+  sendBd_impl(binData, offset, numBytes);
+}
+void HybridSocket::sendBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData, double offset, double numBytes) {
+  if (!this->ck().SendBd(rt::implOf<HybridBinData>(binData, "binData").ck(), rt::toULong(offset, "offset"), rt::toULong(numBytes, "numBytes"))) throw this->fail("sendBd");
+}
+std::shared_ptr<Promise<void>> HybridSocket::sendBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData, double offset, double numBytes) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  return rt::runAsync<void>("Socket.sendBdAsync", std::move(_parts), [_self, binData, offset, numBytes]() {
+    _self->sendBd_impl(binData, offset, numBytes);
+  });
+}
+
+void HybridSocket::sendSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  sendSb_impl(sb);
+}
+void HybridSocket::sendSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().SendSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("sendSb");
+}
+std::shared_ptr<Promise<void>> HybridSocket::sendSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<void>("Socket.sendSbAsync", std::move(_parts), [_self, sb]() {
+    _self->sendSb_impl(sb);
+  });
+}
+
+void HybridSocket::receiveBdN(double numBytes, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  receiveBdN_impl(numBytes, binData);
+}
+void HybridSocket::receiveBdN_impl(double numBytes, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().ReceiveBdN(rt::toULong(numBytes, "numBytes"), rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("receiveBdN");
+}
+std::shared_ptr<Promise<void>> HybridSocket::receiveBdNAsync(double numBytes, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  return rt::runAsync<void>("Socket.receiveBdNAsync", std::move(_parts), [_self, numBytes, binData]() {
+    _self->receiveBdN_impl(numBytes, binData);
+  });
+}
+
+void HybridSocket::sendWakeOnLan(const std::string& macAddress, double port, const std::string& ipBroadcastAddr) {
+  this->beginCall();
+  sendWakeOnLan_impl(macAddress, port, ipBroadcastAddr);
+}
+void HybridSocket::sendWakeOnLan_impl(const std::string& macAddress, double port, const std::string& ipBroadcastAddr) {
+  rt::checkNoNul(macAddress, "macAddress");
+  rt::checkNoNul(ipBroadcastAddr, "ipBroadcastAddr");
+  if (!this->ck().SendWakeOnLan(macAddress.c_str(), rt::toInt(port, "port"), ipBroadcastAddr.c_str())) throw this->fail("sendWakeOnLan");
+}
+
+double HybridSocket::bindAndListenPortRange(double beginPort, double endPort, double backLog) {
+  this->beginCall();
+  return bindAndListenPortRange_impl(beginPort, endPort, backLog);
+}
+double HybridSocket::bindAndListenPortRange_impl(double beginPort, double endPort, double backLog) {
+  return static_cast<double>(this->ck().BindAndListenPortRange(rt::toInt(beginPort, "beginPort"), rt::toInt(endPort, "endPort"), rt::toInt(backLog, "backLog")));
+}
+std::shared_ptr<Promise<double>> HybridSocket::bindAndListenPortRangeAsync(double beginPort, double endPort, double backLog) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Socket.bindAndListenPortRangeAsync", std::move(_parts), [_self, beginPort, endPort, backLog]() {
+    return _self->bindAndListenPortRange_impl(beginPort, endPort, backLog);
+  });
+}
+
+void HybridSocket::receiveUntilByteBd(double lookForByte, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  receiveUntilByteBd_impl(lookForByte, bd);
+}
+void HybridSocket::receiveUntilByteBd_impl(double lookForByte, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().ReceiveUntilByteBd(rt::toInt(lookForByte, "lookForByte"), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("receiveUntilByteBd");
+}
+std::shared_ptr<Promise<void>> HybridSocket::receiveUntilByteBdAsync(double lookForByte, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("Socket.receiveUntilByteBdAsync", std::move(_parts), [_self, lookForByte, bd]() {
+    _self->receiveUntilByteBd_impl(lookForByte, bd);
+  });
+}
+
+void HybridSocket::sendWakeOnLan2(const std::string& macAddress, double port, const std::string& ipBroadcastAddr, const std::string& password) {
+  this->beginCall();
+  sendWakeOnLan2_impl(macAddress, port, ipBroadcastAddr, password);
+}
+void HybridSocket::sendWakeOnLan2_impl(const std::string& macAddress, double port, const std::string& ipBroadcastAddr, const std::string& password) {
+  rt::checkNoNul(macAddress, "macAddress");
+  rt::checkNoNul(ipBroadcastAddr, "ipBroadcastAddr");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().SendWakeOnLan2(macAddress.c_str(), rt::toInt(port, "port"), ipBroadcastAddr.c_str(), password.c_str())) throw this->fail("sendWakeOnLan2");
+}
+
+void HybridSocket::takeConnection(const std::shared_ptr<HybridSocketSpec>& sock) {
+  this->beginCall();
+  takeConnection_impl(sock);
+}
+void HybridSocket::takeConnection_impl(const std::shared_ptr<HybridSocketSpec>& sock) {
+  if (!this->ck().TakeConnection(rt::implOf<HybridSocket>(sock, "sock").ck())) throw this->fail("takeConnection");
+}
+
+void HybridSocket::resetPerf(bool rcvPerf) {
+  this->beginCall();
+  resetPerf_impl(rcvPerf);
+}
+void HybridSocket::resetPerf_impl(bool rcvPerf) {
+  this->ck().ResetPerf(rcvPerf);
+}
+
+void HybridSocket::sendBytes2(const std::shared_ptr<ArrayBuffer>& byteData) {
+  this->beginCall();
+  rt::ByteView _byteData = rt::viewOf(byteData);
+  sendBytes2_impl(_byteData.data, _byteData.size);
+}
+void HybridSocket::sendBytes2_impl(const uint8_t* byteDataData, size_t byteDataSize) {
+  if (!this->ck().SendBytes2(static_cast<const void*>(byteDataData), static_cast<unsigned long>(byteDataSize))) throw this->fail("sendBytes2");
+}
+
+void HybridSocket::receiveUntilMatchSb(const std::string& matchStr, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  receiveUntilMatchSb_impl(matchStr, sb);
+}
+void HybridSocket::receiveUntilMatchSb_impl(const std::string& matchStr, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  rt::checkNoNul(matchStr, "matchStr");
+  if (!this->ck().ReceiveUntilMatchSb(matchStr.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("receiveUntilMatchSb");
+}
+std::shared_ptr<Promise<void>> HybridSocket::receiveUntilMatchSbAsync(const std::string& matchStr, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<void>("Socket.receiveUntilMatchSbAsync", std::move(_parts), [_self, matchStr, sb]() {
+    _self->receiveUntilMatchSb_impl(matchStr, sb);
+  });
+}
+
+void HybridSocket::getAdaptersAddresses(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getAdaptersAddresses_impl(json);
+}
+void HybridSocket::getAdaptersAddresses_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().GetAdaptersAddresses(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("getAdaptersAddresses");
+}
+
+void HybridSocket::getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getLastJsonData_impl(json);
+}
+void HybridSocket::getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->ck().GetLastJsonData(rt::implOf<HybridJsonObject>(json, "json").ck());
+}
+
+void HybridSocket::getServerCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  getServerCert_impl(cert);
+}
+void HybridSocket::getServerCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().GetServerCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("getServerCert");
+}
+
+void HybridSocket::acceptNext(double maxWaitMs, const std::shared_ptr<HybridSocketSpec>& socket) {
+  this->beginCall();
+  acceptNext_impl(maxWaitMs, socket);
+}
+void HybridSocket::acceptNext_impl(double maxWaitMs, const std::shared_ptr<HybridSocketSpec>& socket) {
+  if (!this->ck().AcceptNext(rt::toInt(maxWaitMs, "maxWaitMs"), rt::implOf<HybridSocket>(socket, "socket").ck())) throw this->fail("acceptNext");
+}
+std::shared_ptr<Promise<void>> HybridSocket::acceptNextAsync(double maxWaitMs, const std::shared_ptr<HybridSocketSpec>& socket) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(socket);
+  return rt::runAsync<void>("Socket.acceptNextAsync", std::move(_parts), [_self, maxWaitMs, socket]() {
+    _self->acceptNext_impl(maxWaitMs, socket);
+  });
+}
+
+void HybridSocket::dupSocket(const std::shared_ptr<HybridSocketSpec>& dest) {
+  this->beginCall();
+  dupSocket_impl(dest);
+}
+void HybridSocket::dupSocket_impl(const std::shared_ptr<HybridSocketSpec>& dest) {
+  if (!this->ck().DupSocket(rt::implOf<HybridSocket>(dest, "dest").ck())) throw this->fail("dupSocket");
+}
+
+void HybridSocket::getMyServerCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  getMyServerCert_impl(cert);
+}
+void HybridSocket::getMyServerCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().GetMyServerCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("getMyServerCert");
+}
+
+void HybridSocket::getRcvdClientCert(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  getRcvdClientCert_impl(index, cert);
+}
+void HybridSocket::getRcvdClientCert_impl(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().GetRcvdClientCert(rt::toInt(index, "index"), rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("getRcvdClientCert");
+}
+
+void HybridSocket::sshNewChannel(const std::string& hostname, double port, bool ssl, double maxWaitMs, const std::shared_ptr<HybridSocketSpec>& channel) {
+  this->beginCall();
+  sshNewChannel_impl(hostname, port, ssl, maxWaitMs, channel);
+}
+void HybridSocket::sshNewChannel_impl(const std::string& hostname, double port, bool ssl, double maxWaitMs, const std::shared_ptr<HybridSocketSpec>& channel) {
+  rt::checkNoNul(hostname, "hostname");
+  if (!this->ck().SshNewChannel(hostname.c_str(), rt::toInt(port, "port"), ssl, rt::toInt(maxWaitMs, "maxWaitMs"), rt::implOf<HybridSocket>(channel, "channel").ck())) throw this->fail("sshNewChannel");
+}
+std::shared_ptr<Promise<void>> HybridSocket::sshNewChannelAsync(const std::string& hostname, double port, bool ssl, double maxWaitMs, const std::shared_ptr<HybridSocketSpec>& channel) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSocket>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(channel);
+  return rt::runAsync<void>("Socket.sshNewChannelAsync", std::move(_parts), [_self, hostname, port, ssl, maxWaitMs, channel]() {
+    _self->sshNewChannel_impl(hostname, port, ssl, maxWaitMs, channel);
+  });
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridSocket::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridSocket::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridSocket::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridSocket::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridSocket::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat