@chilkat/react-native 11.6.1

package/cpp/HybridSshTunnel.hpp

@@ -0,0 +1,159 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// SshTunnel: the Nitro HybridObject over Chilkat's CkSshTunnel (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridSshTunnelSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkSshTunnel.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridSshTunnel final : public HybridSshTunnelSpec, public ChilkatObject<CkSshTunnel> {
+public:
+  HybridSshTunnel();                                  // `new SshTunnel()` from JS
+  explicit HybridSshTunnel(CkSshTunnel* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  std::string getAcceptLog() override;
+  void setAcceptLog(const std::string& value) override;
+  std::string getAcceptLogPath() override;
+  void setAcceptLogPath(const std::string& value) override;
+  double getConnectTimeoutMs() override;
+  void setConnectTimeoutMs(double value) override;
+  std::string getDestHostname() override;
+  void setDestHostname(const std::string& value) override;
+  double getDestPort() override;
+  void setDestPort(double value) override;
+  bool getDynamicPortForwarding() override;
+  void setDynamicPortForwarding(bool value) override;
+  std::string getHttpProxyAuthMethod() override;
+  void setHttpProxyAuthMethod(const std::string& value) override;
+  std::string getHttpProxyDomain() override;
+  void setHttpProxyDomain(const std::string& value) override;
+  std::string getHttpProxyHostname() override;
+  void setHttpProxyHostname(const std::string& value) override;
+  std::string getHttpProxyPassword() override;
+  void setHttpProxyPassword(const std::string& value) override;
+  double getHttpProxyPort() override;
+  void setHttpProxyPort(double value) override;
+  std::string getHttpProxyUsername() override;
+  void setHttpProxyUsername(const std::string& value) override;
+  double getIdleTimeoutMs() override;
+  void setIdleTimeoutMs(double value) override;
+  std::string getInboundSocksPassword() override;
+  void setInboundSocksPassword(const std::string& value) override;
+  std::string getInboundSocksUsername() override;
+  void setInboundSocksUsername(const std::string& value) override;
+  bool getIsAccepting() override;
+  bool getKeepAcceptLog() override;
+  void setKeepAcceptLog(bool value) override;
+  bool getKeepTunnelLog() override;
+  void setKeepTunnelLog(bool value) override;
+  std::string getListenBindIpAddress() override;
+  void setListenBindIpAddress(const std::string& value) override;
+  double getListenPort() override;
+  std::string getOutboundBindIpAddress() override;
+  void setOutboundBindIpAddress(const std::string& value) override;
+  double getOutboundBindPort() override;
+  void setOutboundBindPort(double value) override;
+  double getSoRcvBuf() override;
+  void setSoRcvBuf(double value) override;
+  double getSoSndBuf() override;
+  void setSoSndBuf(double value) override;
+  std::string getSocksHostname() override;
+  void setSocksHostname(const std::string& value) override;
+  std::string getSocksPassword() override;
+  void setSocksPassword(const std::string& value) override;
+  double getSocksPort() override;
+  void setSocksPort(double value) override;
+  std::string getSocksUsername() override;
+  void setSocksUsername(const std::string& value) override;
+  double getSocksVersion() override;
+  void setSocksVersion(double value) override;
+  bool getTcpNoDelay() override;
+  void setTcpNoDelay(bool value) override;
+  std::string getTunnelLog() override;
+  void setTunnelLog(const std::string& value) override;
+  std::string getTunnelLogPath() override;
+  void setTunnelLogPath(const std::string& value) override;
+  std::string getHostKeyFingerprint() override;
+  bool getAbortCurrent() override;
+  void setAbortCurrent(bool value) override;
+  bool getPreferIpv6() override;
+  void setPreferIpv6(bool value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+  std::string getClientIdentifier() override;
+  void setClientIdentifier(const std::string& value) override;
+  std::string getClientLogDir() override;
+  void setClientLogDir(const std::string& value) override;
+  bool getEnableSecrets() override;
+  void setEnableSecrets(bool value) override;
+
+  // ---- Methods ----
+  void authenticatePk(const std::string& username, const std::shared_ptr<HybridSshKeySpec>& privateKey) override;
+  std::shared_ptr<Promise<void>> authenticatePkAsync(const std::string& username, const std::shared_ptr<HybridSshKeySpec>& privateKey) override;
+  void authenticatePw(const std::string& login, const std::string& password) override;
+  std::shared_ptr<Promise<void>> authenticatePwAsync(const std::string& login, const std::string& password) override;
+  void authenticatePwPk(const std::string& username, const std::string& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) override;
+  std::shared_ptr<Promise<void>> authenticatePwPkAsync(const std::string& username, const std::string& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) override;
+  void beginAccepting(double listenPort) override;
+  std::shared_ptr<Promise<void>> beginAcceptingAsync(double listenPort) override;
+  void closeTunnel(bool waitForThreads) override;
+  void connect(const std::string& hostname, double port) override;
+  std::shared_ptr<Promise<void>> connectAsync(const std::string& hostname, double port) override;
+  void disconnectAllClients(bool waitForThreads) override;
+  void stopAccepting(bool waitForThread) override;
+  void connectThroughSsh(const std::shared_ptr<HybridSshSpec>& ssh, const std::string& hostname, double port) override;
+  std::shared_ptr<Promise<void>> connectThroughSshAsync(const std::shared_ptr<HybridSshSpec>& ssh, const std::string& hostname, double port) override;
+  bool isSshConnected() override;
+  std::string getCurrentState() override;
+  void authenticateSecPw(const std::shared_ptr<HybridSecureStringSpec>& login, const std::shared_ptr<HybridSecureStringSpec>& password) override;
+  std::shared_ptr<Promise<void>> authenticateSecPwAsync(const std::shared_ptr<HybridSecureStringSpec>& login, const std::shared_ptr<HybridSecureStringSpec>& password) override;
+  void authenticateSecPwPk(const std::shared_ptr<HybridSecureStringSpec>& username, const std::shared_ptr<HybridSecureStringSpec>& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) override;
+  std::shared_ptr<Promise<void>> authenticateSecPwPkAsync(const std::shared_ptr<HybridSecureStringSpec>& username, const std::shared_ptr<HybridSecureStringSpec>& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) override;
+  std::string startKeyboardAuth(const std::string& login) override;
+  std::shared_ptr<Promise<std::string>> startKeyboardAuthAsync(const std::string& login) override;
+  std::string continueKeyboardAuth(const std::string& response) override;
+  std::shared_ptr<Promise<std::string>> continueKeyboardAuthAsync(const std::string& response) override;
+  void setAllowedAlgorithms(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+
+  // ---- Events (ReactNativeGen_DESIGN.md §6) ----
+  std::optional<std::function<void(double)>> getOnPercentDone() override;
+  void setOnPercentDone(const std::optional<std::function<void(double)>>& cb) override;
+  std::optional<std::function<void(const std::string&, const std::string&)>> getOnProgressInfo() override;
+  void setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) override;
+  void abort() override;
+
+private:
+  void init();
+  void authenticatePk_impl(const std::string& username, const std::shared_ptr<HybridSshKeySpec>& privateKey);
+  void authenticatePw_impl(const std::string& login, const std::string& password);
+  void authenticatePwPk_impl(const std::string& username, const std::string& password, const std::shared_ptr<HybridSshKeySpec>& privateKey);
+  void beginAccepting_impl(double listenPort);
+  void closeTunnel_impl(bool waitForThreads);
+  void connect_impl(const std::string& hostname, double port);
+  void disconnectAllClients_impl(bool waitForThreads);
+  void stopAccepting_impl(bool waitForThread);
+  void connectThroughSsh_impl(const std::shared_ptr<HybridSshSpec>& ssh, const std::string& hostname, double port);
+  bool isSshConnected_impl();
+  std::string getCurrentState_impl();
+  void authenticateSecPw_impl(const std::shared_ptr<HybridSecureStringSpec>& login, const std::shared_ptr<HybridSecureStringSpec>& password);
+  void authenticateSecPwPk_impl(const std::shared_ptr<HybridSecureStringSpec>& username, const std::shared_ptr<HybridSecureStringSpec>& password, const std::shared_ptr<HybridSshKeySpec>& privateKey);
+  std::string startKeyboardAuth_impl(const std::string& login);
+  std::string continueKeyboardAuth_impl(const std::string& response);
+  void setAllowedAlgorithms_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridStream.cpp

@@ -0,0 +1,496 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridStream.hpp"
+#include "HybridBinData.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridStream::HybridStream()
+    : HybridObject(HybridStreamSpec::TAG), ChilkatObject<CkStream>("Stream", CkStream::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridStream::HybridStream(CkStream* owned)
+    : HybridObject(HybridStreamSpec::TAG), ChilkatObject<CkStream>("Stream", owned) {
+  init();
+}
+
+void HybridStream::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridStream::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridStream::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStream::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStream::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStream::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStream::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridStream::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridStream::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridStream::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridStream::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridStream::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridStream::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridStream::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+bool HybridStream::getCanRead() {
+  this->beginCall();
+  return this->ck().get_CanRead();
+}
+bool HybridStream::getCanWrite() {
+  this->beginCall();
+  return this->ck().get_CanWrite();
+}
+bool HybridStream::getDataAvailable() {
+  this->beginCall();
+  return this->ck().get_DataAvailable();
+}
+double HybridStream::getDefaultChunkSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_DefaultChunkSize());
+}
+void HybridStream::setDefaultChunkSize(double value) {
+  this->beginCall();
+  this->ck().put_DefaultChunkSize(rt::toInt(value, "defaultChunkSize"));
+}
+bool HybridStream::getEndOfStream() {
+  this->beginCall();
+  return this->ck().get_EndOfStream();
+}
+bool HybridStream::getIsWriteClosed() {
+  this->beginCall();
+  return this->ck().get_IsWriteClosed();
+}
+double HybridStream::getLength() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Length());
+}
+void HybridStream::setLength(double value) {
+  this->beginCall();
+  this->ck().put_Length(rt::toInt64(value, "length"));
+}
+double HybridStream::getLength32() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Length32());
+}
+void HybridStream::setLength32(double value) {
+  this->beginCall();
+  this->ck().put_Length32(rt::toInt(value, "length32"));
+}
+double HybridStream::getNumReceived() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumReceived());
+}
+double HybridStream::getNumSent() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumSent());
+}
+double HybridStream::getReadFailReason() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ReadFailReason());
+}
+double HybridStream::getReadTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ReadTimeoutMs());
+}
+void HybridStream::setReadTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_ReadTimeoutMs(rt::toInt(value, "readTimeoutMs"));
+}
+std::string HybridStream::getSinkFile() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SinkFile(_s);
+  return rt::stdString(_s);
+}
+void HybridStream::setSinkFile(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sinkFile");
+  this->ck().put_SinkFile(value.c_str());
+}
+std::string HybridStream::getSourceFile() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SourceFile(_s);
+  return rt::stdString(_s);
+}
+void HybridStream::setSourceFile(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sourceFile");
+  this->ck().put_SourceFile(value.c_str());
+}
+bool HybridStream::getStringBom() {
+  this->beginCall();
+  return this->ck().get_StringBom();
+}
+void HybridStream::setStringBom(bool value) {
+  this->beginCall();
+  this->ck().put_StringBom(value);
+}
+std::string HybridStream::getStringCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_StringCharset(_s);
+  return rt::stdString(_s);
+}
+void HybridStream::setStringCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "stringCharset");
+  this->ck().put_StringCharset(value.c_str());
+}
+double HybridStream::getWriteFailReason() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_WriteFailReason());
+}
+double HybridStream::getWriteTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_WriteTimeoutMs());
+}
+void HybridStream::setWriteTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_WriteTimeoutMs(rt::toInt(value, "writeTimeoutMs"));
+}
+double HybridStream::getSourceFilePart() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SourceFilePart());
+}
+void HybridStream::setSourceFilePart(double value) {
+  this->beginCall();
+  this->ck().put_SourceFilePart(rt::toInt(value, "sourceFilePart"));
+}
+double HybridStream::getSourceFilePartSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_SourceFilePartSize());
+}
+void HybridStream::setSourceFilePartSize(double value) {
+  this->beginCall();
+  this->ck().put_SourceFilePartSize(rt::toInt(value, "sourceFilePartSize"));
+}
+bool HybridStream::getSinkFileAppend() {
+  this->beginCall();
+  return this->ck().get_SinkFileAppend();
+}
+void HybridStream::setSinkFileAppend(bool value) {
+  this->beginCall();
+  this->ck().put_SinkFileAppend(value);
+}
+double HybridStream::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridStream::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+
+// ---- Methods ----
+
+std::string HybridStream::readBytesENC(const std::string& encoding) {
+  this->beginCall();
+  return readBytesENC_impl(encoding);
+}
+std::string HybridStream::readBytesENC_impl(const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().ReadBytesENC(encoding.c_str(), _out)) throw this->fail("readBytesENC");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridStream::readBytesENCAsync(const std::string& encoding) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridStream>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Stream.readBytesENCAsync", std::move(_parts), [_self, encoding]() {
+    return _self->readBytesENC_impl(encoding);
+  });
+}
+
+std::string HybridStream::readNBytesENC(double numBytes, const std::string& encoding) {
+  this->beginCall();
+  return readNBytesENC_impl(numBytes, encoding);
+}
+std::string HybridStream::readNBytesENC_impl(double numBytes, const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().ReadNBytesENC(rt::toInt(numBytes, "numBytes"), encoding.c_str(), _out)) throw this->fail("readNBytesENC");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridStream::readNBytesENCAsync(double numBytes, const std::string& encoding) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridStream>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Stream.readNBytesENCAsync", std::move(_parts), [_self, numBytes, encoding]() {
+    return _self->readNBytesENC_impl(numBytes, encoding);
+  });
+}
+
+std::string HybridStream::readString() {
+  this->beginCall();
+  return readString_impl();
+}
+std::string HybridStream::readString_impl() {
+  CkString _out;
+  if (!this->ck().ReadString(_out)) throw this->fail("readString");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridStream::readStringAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridStream>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Stream.readStringAsync", std::move(_parts), [_self]() {
+    return _self->readString_impl();
+  });
+}
+
+std::string HybridStream::readToCRLF() {
+  this->beginCall();
+  return readToCRLF_impl();
+}
+std::string HybridStream::readToCRLF_impl() {
+  CkString _out;
+  if (!this->ck().ReadToCRLF(_out)) throw this->fail("readToCRLF");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridStream::readToCRLFAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridStream>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Stream.readToCRLFAsync", std::move(_parts), [_self]() {
+    return _self->readToCRLF_impl();
+  });
+}
+
+std::string HybridStream::readUntilMatch(const std::string& matchStr) {
+  this->beginCall();
+  return readUntilMatch_impl(matchStr);
+}
+std::string HybridStream::readUntilMatch_impl(const std::string& matchStr) {
+  rt::checkNoNul(matchStr, "matchStr");
+  CkString _out;
+  if (!this->ck().ReadUntilMatch(matchStr.c_str(), _out)) throw this->fail("readUntilMatch");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridStream::readUntilMatchAsync(const std::string& matchStr) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridStream>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Stream.readUntilMatchAsync", std::move(_parts), [_self, matchStr]() {
+    return _self->readUntilMatch_impl(matchStr);
+  });
+}
+
+void HybridStream::reset() {
+  this->beginCall();
+  reset_impl();
+}
+void HybridStream::reset_impl() {
+  this->ck().Reset();
+}
+
+void HybridStream::setSourceString(const std::string& srcStr, const std::string& charset) {
+  this->beginCall();
+  setSourceString_impl(srcStr, charset);
+}
+void HybridStream::setSourceString_impl(const std::string& srcStr, const std::string& charset) {
+  rt::checkNoNul(srcStr, "srcStr");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().SetSourceString(srcStr.c_str(), charset.c_str())) throw this->fail("setSourceString");
+}
+
+void HybridStream::writeByte(double byteVal) {
+  this->beginCall();
+  writeByte_impl(byteVal);
+}
+void HybridStream::writeByte_impl(double byteVal) {
+  if (!this->ck().WriteByte(rt::toInt(byteVal, "byteVal"))) throw this->fail("writeByte");
+}
+std::shared_ptr<Promise<void>> HybridStream::writeByteAsync(double byteVal) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridStream>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Stream.writeByteAsync", std::move(_parts), [_self, byteVal]() {
+    _self->writeByte_impl(byteVal);
+  });
+}
+
+void HybridStream::writeBytesENC(const std::string& byteData, const std::string& encoding) {
+  this->beginCall();
+  writeBytesENC_impl(byteData, encoding);
+}
+void HybridStream::writeBytesENC_impl(const std::string& byteData, const std::string& encoding) {
+  rt::checkNoNul(byteData, "byteData");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().WriteBytesENC(byteData.c_str(), encoding.c_str())) throw this->fail("writeBytesENC");
+}
+std::shared_ptr<Promise<void>> HybridStream::writeBytesENCAsync(const std::string& byteData, const std::string& encoding) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridStream>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Stream.writeBytesENCAsync", std::move(_parts), [_self, byteData, encoding]() {
+    _self->writeBytesENC_impl(byteData, encoding);
+  });
+}
+
+void HybridStream::writeClose() {
+  this->beginCall();
+  writeClose_impl();
+}
+void HybridStream::writeClose_impl() {
+  if (!this->ck().WriteClose()) throw this->fail("writeClose");
+}
+
+void HybridStream::writeString(const std::string& str) {
+  this->beginCall();
+  writeString_impl(str);
+}
+void HybridStream::writeString_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  if (!this->ck().WriteString(str.c_str())) throw this->fail("writeString");
+}
+std::shared_ptr<Promise<void>> HybridStream::writeStringAsync(const std::string& str) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridStream>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Stream.writeStringAsync", std::move(_parts), [_self, str]() {
+    _self->writeString_impl(str);
+  });
+}
+
+void HybridStream::readBd(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  readBd_impl(binData);
+}
+void HybridStream::readBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().ReadBd(rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("readBd");
+}
+std::shared_ptr<Promise<void>> HybridStream::readBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridStream>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  return rt::runAsync<void>("Stream.readBdAsync", std::move(_parts), [_self, binData]() {
+    _self->readBd_impl(binData);
+  });
+}
+
+void HybridStream::readSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  readSb_impl(sb);
+}
+void HybridStream::readSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().ReadSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("readSb");
+}
+std::shared_ptr<Promise<void>> HybridStream::readSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridStream>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<void>("Stream.readSbAsync", std::move(_parts), [_self, sb]() {
+    _self->readSb_impl(sb);
+  });
+}
+
+void HybridStream::writeBd(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  writeBd_impl(binData);
+}
+void HybridStream::writeBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().WriteBd(rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("writeBd");
+}
+std::shared_ptr<Promise<void>> HybridStream::writeBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridStream>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  return rt::runAsync<void>("Stream.writeBdAsync", std::move(_parts), [_self, binData]() {
+    _self->writeBd_impl(binData);
+  });
+}
+
+void HybridStream::writeSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  writeSb_impl(sb);
+}
+void HybridStream::writeSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().WriteSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("writeSb");
+}
+std::shared_ptr<Promise<void>> HybridStream::writeSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridStream>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<void>("Stream.writeSbAsync", std::move(_parts), [_self, sb]() {
+    _self->writeSb_impl(sb);
+  });
+}
+
+void HybridStream::writeBytes2(const std::shared_ptr<ArrayBuffer>& byteData) {
+  this->beginCall();
+  rt::ByteView _byteData = rt::viewOf(byteData);
+  writeBytes2_impl(_byteData.data, _byteData.size);
+}
+void HybridStream::writeBytes2_impl(const uint8_t* byteDataData, size_t byteDataSize) {
+  if (!this->ck().WriteBytes2(static_cast<const void*>(byteDataData), static_cast<unsigned long>(byteDataSize))) throw this->fail("writeBytes2");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridStream::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridStream::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridStream::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridStream::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridStream::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat