@chilkat/react-native 11.6.1

package/nitrogen/generated/shared/c++/HybridSshSpec.hpp

@@ -0,0 +1,276 @@
+///
+/// HybridSshSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridSshKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSshKeySpec; }
+// Forward declaration of `HybridStringArraySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringArraySpec; }
+// Forward declaration of `HybridSshSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSshSpec; }
+// Forward declaration of `HybridSecureStringSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSecureStringSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridSshKeySpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include "HybridStringArraySpec.hpp"
+#include "HybridSshSpec.hpp"
+#include "HybridSecureStringSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Ssh`
+   * Inherit this class to create instances of `HybridSshSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridSsh: public HybridSshSpec {
+   * public:
+   *   HybridSsh(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridSshSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridSshSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridSshSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual double getAuthFailReason() = 0;
+      virtual bool getCaretControl() = 0;
+      virtual void setCaretControl(bool caretControl) = 0;
+      virtual double getChannelOpenFailCode() = 0;
+      virtual std::string getChannelOpenFailReason() = 0;
+      virtual std::string getClientIdentifier() = 0;
+      virtual void setClientIdentifier(const std::string& clientIdentifier) = 0;
+      virtual std::string getClientIpAddress() = 0;
+      virtual void setClientIpAddress(const std::string& clientIpAddress) = 0;
+      virtual double getConnectTimeoutMs() = 0;
+      virtual void setConnectTimeoutMs(double connectTimeoutMs) = 0;
+      virtual double getDisconnectCode() = 0;
+      virtual std::string getDisconnectReason() = 0;
+      virtual std::string getForceCipher() = 0;
+      virtual void setForceCipher(const std::string& forceCipher) = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual std::string getHostKeyAlg() = 0;
+      virtual void setHostKeyAlg(const std::string& hostKeyAlg) = 0;
+      virtual std::string getHostKeyFingerprint() = 0;
+      virtual std::string getHttpProxyAuthMethod() = 0;
+      virtual void setHttpProxyAuthMethod(const std::string& httpProxyAuthMethod) = 0;
+      virtual std::string getHttpProxyDomain() = 0;
+      virtual void setHttpProxyDomain(const std::string& httpProxyDomain) = 0;
+      virtual std::string getHttpProxyHostname() = 0;
+      virtual void setHttpProxyHostname(const std::string& httpProxyHostname) = 0;
+      virtual std::string getHttpProxyPassword() = 0;
+      virtual void setHttpProxyPassword(const std::string& httpProxyPassword) = 0;
+      virtual double getHttpProxyPort() = 0;
+      virtual void setHttpProxyPort(double httpProxyPort) = 0;
+      virtual std::string getHttpProxyUsername() = 0;
+      virtual void setHttpProxyUsername(const std::string& httpProxyUsername) = 0;
+      virtual double getIdleTimeoutMs() = 0;
+      virtual void setIdleTimeoutMs(double idleTimeoutMs) = 0;
+      virtual bool getIsConnected() = 0;
+      virtual bool getKeepSessionLog() = 0;
+      virtual void setKeepSessionLog(bool keepSessionLog) = 0;
+      virtual double getMaxPacketSize() = 0;
+      virtual void setMaxPacketSize(double maxPacketSize) = 0;
+      virtual double getNumOpenChannels() = 0;
+      virtual bool getPasswordChangeRequested() = 0;
+      virtual bool getPreferIpv6() = 0;
+      virtual void setPreferIpv6(bool preferIpv6) = 0;
+      virtual double getReadTimeoutMs() = 0;
+      virtual void setReadTimeoutMs(double readTimeoutMs) = 0;
+      virtual std::string getReqExecCharset() = 0;
+      virtual void setReqExecCharset(const std::string& reqExecCharset) = 0;
+      virtual std::string getSessionLog() = 0;
+      virtual double getSoRcvBuf() = 0;
+      virtual void setSoRcvBuf(double soRcvBuf) = 0;
+      virtual double getSoSndBuf() = 0;
+      virtual void setSoSndBuf(double soSndBuf) = 0;
+      virtual std::string getSocksHostname() = 0;
+      virtual void setSocksHostname(const std::string& socksHostname) = 0;
+      virtual std::string getSocksPassword() = 0;
+      virtual void setSocksPassword(const std::string& socksPassword) = 0;
+      virtual double getSocksPort() = 0;
+      virtual void setSocksPort(double socksPort) = 0;
+      virtual std::string getSocksUsername() = 0;
+      virtual void setSocksUsername(const std::string& socksUsername) = 0;
+      virtual double getSocksVersion() = 0;
+      virtual void setSocksVersion(double socksVersion) = 0;
+      virtual bool getStderrToStdout() = 0;
+      virtual void setStderrToStdout(bool stderrToStdout) = 0;
+      virtual bool getTcpNoDelay() = 0;
+      virtual void setTcpNoDelay(bool tcpNoDelay) = 0;
+      virtual std::string getUserAuthBanner() = 0;
+      virtual void setUserAuthBanner(const std::string& userAuthBanner) = 0;
+      virtual bool getEnableCompression() = 0;
+      virtual void setEnableCompression(bool enableCompression) = 0;
+      virtual bool getAbortCurrent() = 0;
+      virtual void setAbortCurrent(bool abortCurrent) = 0;
+      virtual bool getStripColorCodes() = 0;
+      virtual void setStripColorCodes(bool stripColorCodes) = 0;
+      virtual std::string getServerIdentifier() = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual double getClientPort() = 0;
+      virtual void setClientPort(double clientPort) = 0;
+      virtual bool getEnableSecrets() = 0;
+      virtual void setEnableSecrets(bool enableSecrets) = 0;
+      virtual std::optional<std::function<void(double /* pctDone */)>> getOnPercentDone() = 0;
+      virtual void setOnPercentDone(const std::optional<std::function<void(double /* pctDone */)>>& onPercentDone) = 0;
+      virtual std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>> getOnProgressInfo() = 0;
+      virtual void setOnProgressInfo(const std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>>& onProgressInfo) = 0;
+
+    public:
+      // Methods
+      virtual void authenticatePk(const std::string& username, const std::shared_ptr<HybridSshKeySpec>& privateKey) = 0;
+      virtual std::shared_ptr<Promise<void>> authenticatePkAsync(const std::string& username, const std::shared_ptr<HybridSshKeySpec>& privateKey) = 0;
+      virtual void authenticatePw(const std::string& login, const std::string& password) = 0;
+      virtual std::shared_ptr<Promise<void>> authenticatePwAsync(const std::string& login, const std::string& password) = 0;
+      virtual void authenticatePwPk(const std::string& username, const std::string& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) = 0;
+      virtual std::shared_ptr<Promise<void>> authenticatePwPkAsync(const std::string& username, const std::string& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) = 0;
+      virtual bool channelIsOpen(double channelNum) = 0;
+      virtual double channelPoll(double channelNum, double pollTimeoutMs) = 0;
+      virtual std::shared_ptr<Promise<double>> channelPollAsync(double channelNum, double pollTimeoutMs) = 0;
+      virtual double channelRead(double channelNum) = 0;
+      virtual std::shared_ptr<Promise<double>> channelReadAsync(double channelNum) = 0;
+      virtual double channelReadAndPoll(double channelNum, double pollTimeoutMs) = 0;
+      virtual std::shared_ptr<Promise<double>> channelReadAndPollAsync(double channelNum, double pollTimeoutMs) = 0;
+      virtual double channelReadAndPoll2(double channelNum, double pollTimeoutMs, double maxNumBytes) = 0;
+      virtual std::shared_ptr<Promise<double>> channelReadAndPoll2Async(double channelNum, double pollTimeoutMs, double maxNumBytes) = 0;
+      virtual void channelReceiveToClose(double channelNum) = 0;
+      virtual std::shared_ptr<Promise<void>> channelReceiveToCloseAsync(double channelNum) = 0;
+      virtual void channelReceiveUntilMatch(double channelNum, const std::string& matchPattern, const std::string& charset, bool caseSensitive) = 0;
+      virtual std::shared_ptr<Promise<void>> channelReceiveUntilMatchAsync(double channelNum, const std::string& matchPattern, const std::string& charset, bool caseSensitive) = 0;
+      virtual void channelReceiveUntilMatchN(double channelNum, const std::shared_ptr<HybridStringArraySpec>& matchPatterns, const std::string& charset, bool caseSensitive) = 0;
+      virtual std::shared_ptr<Promise<void>> channelReceiveUntilMatchNAsync(double channelNum, const std::shared_ptr<HybridStringArraySpec>& matchPatterns, const std::string& charset, bool caseSensitive) = 0;
+      virtual bool channelReceivedClose(double channelNum) = 0;
+      virtual bool channelReceivedEof(double channelNum) = 0;
+      virtual bool channelReceivedExitStatus(double channelNum) = 0;
+      virtual void channelRelease(double channelNum) = 0;
+      virtual void channelSendClose(double channelNum) = 0;
+      virtual std::shared_ptr<Promise<void>> channelSendCloseAsync(double channelNum) = 0;
+      virtual void channelSendEof(double channelNum) = 0;
+      virtual std::shared_ptr<Promise<void>> channelSendEofAsync(double channelNum) = 0;
+      virtual void channelSendString(double channelNum, const std::string& textData, const std::string& charset) = 0;
+      virtual std::shared_ptr<Promise<void>> channelSendStringAsync(double channelNum, const std::string& textData, const std::string& charset) = 0;
+      virtual bool checkConnection() = 0;
+      virtual void clearTtyModes() = 0;
+      virtual void connect(const std::string& domainName, double port) = 0;
+      virtual std::shared_ptr<Promise<void>> connectAsync(const std::string& domainName, double port) = 0;
+      virtual void connectThroughSsh(const std::shared_ptr<HybridSshSpec>& ssh, const std::string& hostname, double port) = 0;
+      virtual std::shared_ptr<Promise<void>> connectThroughSshAsync(const std::shared_ptr<HybridSshSpec>& ssh, const std::string& hostname, double port) = 0;
+      virtual std::string continueKeyboardAuth(const std::string& response) = 0;
+      virtual std::shared_ptr<Promise<std::string>> continueKeyboardAuthAsync(const std::string& response) = 0;
+      virtual void disconnect() = 0;
+      virtual double getChannelExitStatus(double channelNum) = 0;
+      virtual double getChannelNumber(double index) = 0;
+      virtual std::string getChannelType(double index) = 0;
+      virtual double getReceivedNumBytes(double channelNum) = 0;
+      virtual std::string getReceivedStderrText(double channelNum, const std::string& charset) = 0;
+      virtual std::string getReceivedText(double channelNum, const std::string& charset) = 0;
+      virtual std::string getReceivedTextS(double channelNum, const std::string& substr, const std::string& charset) = 0;
+      virtual double openCustomChannel(const std::string& channelType) = 0;
+      virtual std::shared_ptr<Promise<double>> openCustomChannelAsync(const std::string& channelType) = 0;
+      virtual double openDirectTcpIpChannel(const std::string& targetHostname, double targetPort) = 0;
+      virtual std::shared_ptr<Promise<double>> openDirectTcpIpChannelAsync(const std::string& targetHostname, double targetPort) = 0;
+      virtual double openSessionChannel() = 0;
+      virtual std::shared_ptr<Promise<double>> openSessionChannelAsync() = 0;
+      virtual std::string peekReceivedText(double channelNum, const std::string& charset) = 0;
+      virtual void reKey() = 0;
+      virtual std::shared_ptr<Promise<void>> reKeyAsync() = 0;
+      virtual void sendIgnore() = 0;
+      virtual std::shared_ptr<Promise<void>> sendIgnoreAsync() = 0;
+      virtual void sendReqExec(double channelNum, const std::string& commandLine) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqExecAsync(double channelNum, const std::string& commandLine) = 0;
+      virtual void sendReqPty(double channelNum, const std::string& termType, double widthInChars, double heightInChars, double widthInPixels, double heightInPixels) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqPtyAsync(double channelNum, const std::string& termType, double widthInChars, double heightInChars, double widthInPixels, double heightInPixels) = 0;
+      virtual void sendReqSetEnv(double channelNum, const std::string& name, const std::string& value) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqSetEnvAsync(double channelNum, const std::string& name, const std::string& value) = 0;
+      virtual void sendReqShell(double channelNum) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqShellAsync(double channelNum) = 0;
+      virtual void sendReqSignal(double channelNum, const std::string& signalName) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqSignalAsync(double channelNum, const std::string& signalName) = 0;
+      virtual void sendReqSubsystem(double channelNum, const std::string& subsystemName) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqSubsystemAsync(double channelNum, const std::string& subsystemName) = 0;
+      virtual void sendReqWindowChange(double channelNum, double widthInChars, double heightInRows, double pixWidth, double pixHeight) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqWindowChangeAsync(double channelNum, double widthInChars, double heightInRows, double pixWidth, double pixHeight) = 0;
+      virtual void sendReqX11Forwarding(double channelNum, bool singleConnection, const std::string& authProt, const std::string& authCookie, double screenNum) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqX11ForwardingAsync(double channelNum, bool singleConnection, const std::string& authProt, const std::string& authCookie, double screenNum) = 0;
+      virtual void sendReqXonXoff(double channelNum, bool clientCanDo) = 0;
+      virtual std::shared_ptr<Promise<void>> sendReqXonXoffAsync(double channelNum, bool clientCanDo) = 0;
+      virtual void setTtyMode(const std::string& ttyName, double ttyValue) = 0;
+      virtual std::string startKeyboardAuth(const std::string& login) = 0;
+      virtual std::shared_ptr<Promise<std::string>> startKeyboardAuthAsync(const std::string& login) = 0;
+      virtual double waitForChannelMessage(double pollTimeoutMs) = 0;
+      virtual std::shared_ptr<Promise<double>> waitForChannelMessageAsync(double pollTimeoutMs) = 0;
+      virtual std::string quickCommand(const std::string& command, const std::string& charset) = 0;
+      virtual std::shared_ptr<Promise<std::string>> quickCommandAsync(const std::string& command, const std::string& charset) = 0;
+      virtual double quickShell() = 0;
+      virtual std::shared_ptr<Promise<double>> quickShellAsync() = 0;
+      virtual double quickCmdSend(const std::string& command) = 0;
+      virtual std::shared_ptr<Promise<double>> quickCmdSendAsync(const std::string& command) = 0;
+      virtual double quickCmdCheck(double pollTimeoutMs) = 0;
+      virtual std::shared_ptr<Promise<double>> quickCmdCheckAsync(double pollTimeoutMs) = 0;
+      virtual void authenticateSecPw(const std::shared_ptr<HybridSecureStringSpec>& login, const std::shared_ptr<HybridSecureStringSpec>& password) = 0;
+      virtual std::shared_ptr<Promise<void>> authenticateSecPwAsync(const std::shared_ptr<HybridSecureStringSpec>& login, const std::shared_ptr<HybridSecureStringSpec>& password) = 0;
+      virtual void authenticateSecPwPk(const std::shared_ptr<HybridSecureStringSpec>& username, const std::shared_ptr<HybridSecureStringSpec>& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) = 0;
+      virtual std::shared_ptr<Promise<void>> authenticateSecPwPkAsync(const std::shared_ptr<HybridSecureStringSpec>& username, const std::shared_ptr<HybridSecureStringSpec>& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) = 0;
+      virtual std::string getAuthMethods() = 0;
+      virtual std::shared_ptr<Promise<std::string>> getAuthMethodsAsync() = 0;
+      virtual std::string getHostKeyFP(const std::string& hashAlg, bool includeKeyType, bool includeHashName) = 0;
+      virtual void setAllowedAlgorithms(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void getReceivedSb(double channelNum, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Ssh";
+  };
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridSshTunnelSpec.cpp

@@ -0,0 +1,136 @@
+///
+/// HybridSshTunnelSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridSshTunnelSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridSshTunnelSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridSshTunnelSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridSshTunnelSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridSshTunnelSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridSshTunnelSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridSshTunnelSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridSshTunnelSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridSshTunnelSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridSshTunnelSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridSshTunnelSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridSshTunnelSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("acceptLog", &HybridSshTunnelSpec::getAcceptLog);
+      prototype.registerHybridSetter("acceptLog", &HybridSshTunnelSpec::setAcceptLog);
+      prototype.registerHybridGetter("acceptLogPath", &HybridSshTunnelSpec::getAcceptLogPath);
+      prototype.registerHybridSetter("acceptLogPath", &HybridSshTunnelSpec::setAcceptLogPath);
+      prototype.registerHybridGetter("connectTimeoutMs", &HybridSshTunnelSpec::getConnectTimeoutMs);
+      prototype.registerHybridSetter("connectTimeoutMs", &HybridSshTunnelSpec::setConnectTimeoutMs);
+      prototype.registerHybridGetter("destHostname", &HybridSshTunnelSpec::getDestHostname);
+      prototype.registerHybridSetter("destHostname", &HybridSshTunnelSpec::setDestHostname);
+      prototype.registerHybridGetter("destPort", &HybridSshTunnelSpec::getDestPort);
+      prototype.registerHybridSetter("destPort", &HybridSshTunnelSpec::setDestPort);
+      prototype.registerHybridGetter("dynamicPortForwarding", &HybridSshTunnelSpec::getDynamicPortForwarding);
+      prototype.registerHybridSetter("dynamicPortForwarding", &HybridSshTunnelSpec::setDynamicPortForwarding);
+      prototype.registerHybridGetter("httpProxyAuthMethod", &HybridSshTunnelSpec::getHttpProxyAuthMethod);
+      prototype.registerHybridSetter("httpProxyAuthMethod", &HybridSshTunnelSpec::setHttpProxyAuthMethod);
+      prototype.registerHybridGetter("httpProxyDomain", &HybridSshTunnelSpec::getHttpProxyDomain);
+      prototype.registerHybridSetter("httpProxyDomain", &HybridSshTunnelSpec::setHttpProxyDomain);
+      prototype.registerHybridGetter("httpProxyHostname", &HybridSshTunnelSpec::getHttpProxyHostname);
+      prototype.registerHybridSetter("httpProxyHostname", &HybridSshTunnelSpec::setHttpProxyHostname);
+      prototype.registerHybridGetter("httpProxyPassword", &HybridSshTunnelSpec::getHttpProxyPassword);
+      prototype.registerHybridSetter("httpProxyPassword", &HybridSshTunnelSpec::setHttpProxyPassword);
+      prototype.registerHybridGetter("httpProxyPort", &HybridSshTunnelSpec::getHttpProxyPort);
+      prototype.registerHybridSetter("httpProxyPort", &HybridSshTunnelSpec::setHttpProxyPort);
+      prototype.registerHybridGetter("httpProxyUsername", &HybridSshTunnelSpec::getHttpProxyUsername);
+      prototype.registerHybridSetter("httpProxyUsername", &HybridSshTunnelSpec::setHttpProxyUsername);
+      prototype.registerHybridGetter("idleTimeoutMs", &HybridSshTunnelSpec::getIdleTimeoutMs);
+      prototype.registerHybridSetter("idleTimeoutMs", &HybridSshTunnelSpec::setIdleTimeoutMs);
+      prototype.registerHybridGetter("inboundSocksPassword", &HybridSshTunnelSpec::getInboundSocksPassword);
+      prototype.registerHybridSetter("inboundSocksPassword", &HybridSshTunnelSpec::setInboundSocksPassword);
+      prototype.registerHybridGetter("inboundSocksUsername", &HybridSshTunnelSpec::getInboundSocksUsername);
+      prototype.registerHybridSetter("inboundSocksUsername", &HybridSshTunnelSpec::setInboundSocksUsername);
+      prototype.registerHybridGetter("isAccepting", &HybridSshTunnelSpec::getIsAccepting);
+      prototype.registerHybridGetter("keepAcceptLog", &HybridSshTunnelSpec::getKeepAcceptLog);
+      prototype.registerHybridSetter("keepAcceptLog", &HybridSshTunnelSpec::setKeepAcceptLog);
+      prototype.registerHybridGetter("keepTunnelLog", &HybridSshTunnelSpec::getKeepTunnelLog);
+      prototype.registerHybridSetter("keepTunnelLog", &HybridSshTunnelSpec::setKeepTunnelLog);
+      prototype.registerHybridGetter("listenBindIpAddress", &HybridSshTunnelSpec::getListenBindIpAddress);
+      prototype.registerHybridSetter("listenBindIpAddress", &HybridSshTunnelSpec::setListenBindIpAddress);
+      prototype.registerHybridGetter("listenPort", &HybridSshTunnelSpec::getListenPort);
+      prototype.registerHybridGetter("outboundBindIpAddress", &HybridSshTunnelSpec::getOutboundBindIpAddress);
+      prototype.registerHybridSetter("outboundBindIpAddress", &HybridSshTunnelSpec::setOutboundBindIpAddress);
+      prototype.registerHybridGetter("outboundBindPort", &HybridSshTunnelSpec::getOutboundBindPort);
+      prototype.registerHybridSetter("outboundBindPort", &HybridSshTunnelSpec::setOutboundBindPort);
+      prototype.registerHybridGetter("soRcvBuf", &HybridSshTunnelSpec::getSoRcvBuf);
+      prototype.registerHybridSetter("soRcvBuf", &HybridSshTunnelSpec::setSoRcvBuf);
+      prototype.registerHybridGetter("soSndBuf", &HybridSshTunnelSpec::getSoSndBuf);
+      prototype.registerHybridSetter("soSndBuf", &HybridSshTunnelSpec::setSoSndBuf);
+      prototype.registerHybridGetter("socksHostname", &HybridSshTunnelSpec::getSocksHostname);
+      prototype.registerHybridSetter("socksHostname", &HybridSshTunnelSpec::setSocksHostname);
+      prototype.registerHybridGetter("socksPassword", &HybridSshTunnelSpec::getSocksPassword);
+      prototype.registerHybridSetter("socksPassword", &HybridSshTunnelSpec::setSocksPassword);
+      prototype.registerHybridGetter("socksPort", &HybridSshTunnelSpec::getSocksPort);
+      prototype.registerHybridSetter("socksPort", &HybridSshTunnelSpec::setSocksPort);
+      prototype.registerHybridGetter("socksUsername", &HybridSshTunnelSpec::getSocksUsername);
+      prototype.registerHybridSetter("socksUsername", &HybridSshTunnelSpec::setSocksUsername);
+      prototype.registerHybridGetter("socksVersion", &HybridSshTunnelSpec::getSocksVersion);
+      prototype.registerHybridSetter("socksVersion", &HybridSshTunnelSpec::setSocksVersion);
+      prototype.registerHybridGetter("tcpNoDelay", &HybridSshTunnelSpec::getTcpNoDelay);
+      prototype.registerHybridSetter("tcpNoDelay", &HybridSshTunnelSpec::setTcpNoDelay);
+      prototype.registerHybridGetter("tunnelLog", &HybridSshTunnelSpec::getTunnelLog);
+      prototype.registerHybridSetter("tunnelLog", &HybridSshTunnelSpec::setTunnelLog);
+      prototype.registerHybridGetter("tunnelLogPath", &HybridSshTunnelSpec::getTunnelLogPath);
+      prototype.registerHybridSetter("tunnelLogPath", &HybridSshTunnelSpec::setTunnelLogPath);
+      prototype.registerHybridGetter("hostKeyFingerprint", &HybridSshTunnelSpec::getHostKeyFingerprint);
+      prototype.registerHybridGetter("abortCurrent", &HybridSshTunnelSpec::getAbortCurrent);
+      prototype.registerHybridSetter("abortCurrent", &HybridSshTunnelSpec::setAbortCurrent);
+      prototype.registerHybridGetter("preferIpv6", &HybridSshTunnelSpec::getPreferIpv6);
+      prototype.registerHybridSetter("preferIpv6", &HybridSshTunnelSpec::setPreferIpv6);
+      prototype.registerHybridGetter("uncommonOptions", &HybridSshTunnelSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridSshTunnelSpec::setUncommonOptions);
+      prototype.registerHybridGetter("clientIdentifier", &HybridSshTunnelSpec::getClientIdentifier);
+      prototype.registerHybridSetter("clientIdentifier", &HybridSshTunnelSpec::setClientIdentifier);
+      prototype.registerHybridGetter("clientLogDir", &HybridSshTunnelSpec::getClientLogDir);
+      prototype.registerHybridSetter("clientLogDir", &HybridSshTunnelSpec::setClientLogDir);
+      prototype.registerHybridGetter("enableSecrets", &HybridSshTunnelSpec::getEnableSecrets);
+      prototype.registerHybridSetter("enableSecrets", &HybridSshTunnelSpec::setEnableSecrets);
+      prototype.registerHybridGetter("onPercentDone", &HybridSshTunnelSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridSshTunnelSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridSshTunnelSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridSshTunnelSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("authenticatePk", &HybridSshTunnelSpec::authenticatePk);
+      prototype.registerHybridMethod("authenticatePkAsync", &HybridSshTunnelSpec::authenticatePkAsync);
+      prototype.registerHybridMethod("authenticatePw", &HybridSshTunnelSpec::authenticatePw);
+      prototype.registerHybridMethod("authenticatePwAsync", &HybridSshTunnelSpec::authenticatePwAsync);
+      prototype.registerHybridMethod("authenticatePwPk", &HybridSshTunnelSpec::authenticatePwPk);
+      prototype.registerHybridMethod("authenticatePwPkAsync", &HybridSshTunnelSpec::authenticatePwPkAsync);
+      prototype.registerHybridMethod("beginAccepting", &HybridSshTunnelSpec::beginAccepting);
+      prototype.registerHybridMethod("beginAcceptingAsync", &HybridSshTunnelSpec::beginAcceptingAsync);
+      prototype.registerHybridMethod("closeTunnel", &HybridSshTunnelSpec::closeTunnel);
+      prototype.registerHybridMethod("connect", &HybridSshTunnelSpec::connect);
+      prototype.registerHybridMethod("connectAsync", &HybridSshTunnelSpec::connectAsync);
+      prototype.registerHybridMethod("disconnectAllClients", &HybridSshTunnelSpec::disconnectAllClients);
+      prototype.registerHybridMethod("stopAccepting", &HybridSshTunnelSpec::stopAccepting);
+      prototype.registerHybridMethod("connectThroughSsh", &HybridSshTunnelSpec::connectThroughSsh);
+      prototype.registerHybridMethod("connectThroughSshAsync", &HybridSshTunnelSpec::connectThroughSshAsync);
+      prototype.registerHybridMethod("isSshConnected", &HybridSshTunnelSpec::isSshConnected);
+      prototype.registerHybridMethod("getCurrentState", &HybridSshTunnelSpec::getCurrentState);
+      prototype.registerHybridMethod("authenticateSecPw", &HybridSshTunnelSpec::authenticateSecPw);
+      prototype.registerHybridMethod("authenticateSecPwAsync", &HybridSshTunnelSpec::authenticateSecPwAsync);
+      prototype.registerHybridMethod("authenticateSecPwPk", &HybridSshTunnelSpec::authenticateSecPwPk);
+      prototype.registerHybridMethod("authenticateSecPwPkAsync", &HybridSshTunnelSpec::authenticateSecPwPkAsync);
+      prototype.registerHybridMethod("startKeyboardAuth", &HybridSshTunnelSpec::startKeyboardAuth);
+      prototype.registerHybridMethod("startKeyboardAuthAsync", &HybridSshTunnelSpec::startKeyboardAuthAsync);
+      prototype.registerHybridMethod("continueKeyboardAuth", &HybridSshTunnelSpec::continueKeyboardAuth);
+      prototype.registerHybridMethod("continueKeyboardAuthAsync", &HybridSshTunnelSpec::continueKeyboardAuthAsync);
+      prototype.registerHybridMethod("setAllowedAlgorithms", &HybridSshTunnelSpec::setAllowedAlgorithms);
+      prototype.registerHybridMethod("abort", &HybridSshTunnelSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridSshTunnelSpec.hpp

@@ -0,0 +1,191 @@
+///
+/// HybridSshTunnelSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridSshKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSshKeySpec; }
+// Forward declaration of `HybridSshSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSshSpec; }
+// Forward declaration of `HybridSecureStringSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSecureStringSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridSshKeySpec.hpp"
+#include <NitroModules/Promise.hpp>
+#include "HybridSshSpec.hpp"
+#include "HybridSecureStringSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `SshTunnel`
+   * Inherit this class to create instances of `HybridSshTunnelSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridSshTunnel: public HybridSshTunnelSpec {
+   * public:
+   *   HybridSshTunnel(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridSshTunnelSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridSshTunnelSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridSshTunnelSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual std::string getAcceptLog() = 0;
+      virtual void setAcceptLog(const std::string& acceptLog) = 0;
+      virtual std::string getAcceptLogPath() = 0;
+      virtual void setAcceptLogPath(const std::string& acceptLogPath) = 0;
+      virtual double getConnectTimeoutMs() = 0;
+      virtual void setConnectTimeoutMs(double connectTimeoutMs) = 0;
+      virtual std::string getDestHostname() = 0;
+      virtual void setDestHostname(const std::string& destHostname) = 0;
+      virtual double getDestPort() = 0;
+      virtual void setDestPort(double destPort) = 0;
+      virtual bool getDynamicPortForwarding() = 0;
+      virtual void setDynamicPortForwarding(bool dynamicPortForwarding) = 0;
+      virtual std::string getHttpProxyAuthMethod() = 0;
+      virtual void setHttpProxyAuthMethod(const std::string& httpProxyAuthMethod) = 0;
+      virtual std::string getHttpProxyDomain() = 0;
+      virtual void setHttpProxyDomain(const std::string& httpProxyDomain) = 0;
+      virtual std::string getHttpProxyHostname() = 0;
+      virtual void setHttpProxyHostname(const std::string& httpProxyHostname) = 0;
+      virtual std::string getHttpProxyPassword() = 0;
+      virtual void setHttpProxyPassword(const std::string& httpProxyPassword) = 0;
+      virtual double getHttpProxyPort() = 0;
+      virtual void setHttpProxyPort(double httpProxyPort) = 0;
+      virtual std::string getHttpProxyUsername() = 0;
+      virtual void setHttpProxyUsername(const std::string& httpProxyUsername) = 0;
+      virtual double getIdleTimeoutMs() = 0;
+      virtual void setIdleTimeoutMs(double idleTimeoutMs) = 0;
+      virtual std::string getInboundSocksPassword() = 0;
+      virtual void setInboundSocksPassword(const std::string& inboundSocksPassword) = 0;
+      virtual std::string getInboundSocksUsername() = 0;
+      virtual void setInboundSocksUsername(const std::string& inboundSocksUsername) = 0;
+      virtual bool getIsAccepting() = 0;
+      virtual bool getKeepAcceptLog() = 0;
+      virtual void setKeepAcceptLog(bool keepAcceptLog) = 0;
+      virtual bool getKeepTunnelLog() = 0;
+      virtual void setKeepTunnelLog(bool keepTunnelLog) = 0;
+      virtual std::string getListenBindIpAddress() = 0;
+      virtual void setListenBindIpAddress(const std::string& listenBindIpAddress) = 0;
+      virtual double getListenPort() = 0;
+      virtual std::string getOutboundBindIpAddress() = 0;
+      virtual void setOutboundBindIpAddress(const std::string& outboundBindIpAddress) = 0;
+      virtual double getOutboundBindPort() = 0;
+      virtual void setOutboundBindPort(double outboundBindPort) = 0;
+      virtual double getSoRcvBuf() = 0;
+      virtual void setSoRcvBuf(double soRcvBuf) = 0;
+      virtual double getSoSndBuf() = 0;
+      virtual void setSoSndBuf(double soSndBuf) = 0;
+      virtual std::string getSocksHostname() = 0;
+      virtual void setSocksHostname(const std::string& socksHostname) = 0;
+      virtual std::string getSocksPassword() = 0;
+      virtual void setSocksPassword(const std::string& socksPassword) = 0;
+      virtual double getSocksPort() = 0;
+      virtual void setSocksPort(double socksPort) = 0;
+      virtual std::string getSocksUsername() = 0;
+      virtual void setSocksUsername(const std::string& socksUsername) = 0;
+      virtual double getSocksVersion() = 0;
+      virtual void setSocksVersion(double socksVersion) = 0;
+      virtual bool getTcpNoDelay() = 0;
+      virtual void setTcpNoDelay(bool tcpNoDelay) = 0;
+      virtual std::string getTunnelLog() = 0;
+      virtual void setTunnelLog(const std::string& tunnelLog) = 0;
+      virtual std::string getTunnelLogPath() = 0;
+      virtual void setTunnelLogPath(const std::string& tunnelLogPath) = 0;
+      virtual std::string getHostKeyFingerprint() = 0;
+      virtual bool getAbortCurrent() = 0;
+      virtual void setAbortCurrent(bool abortCurrent) = 0;
+      virtual bool getPreferIpv6() = 0;
+      virtual void setPreferIpv6(bool preferIpv6) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual std::string getClientIdentifier() = 0;
+      virtual void setClientIdentifier(const std::string& clientIdentifier) = 0;
+      virtual std::string getClientLogDir() = 0;
+      virtual void setClientLogDir(const std::string& clientLogDir) = 0;
+      virtual bool getEnableSecrets() = 0;
+      virtual void setEnableSecrets(bool enableSecrets) = 0;
+      virtual std::optional<std::function<void(double /* pctDone */)>> getOnPercentDone() = 0;
+      virtual void setOnPercentDone(const std::optional<std::function<void(double /* pctDone */)>>& onPercentDone) = 0;
+      virtual std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>> getOnProgressInfo() = 0;
+      virtual void setOnProgressInfo(const std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>>& onProgressInfo) = 0;
+
+    public:
+      // Methods
+      virtual void authenticatePk(const std::string& username, const std::shared_ptr<HybridSshKeySpec>& privateKey) = 0;
+      virtual std::shared_ptr<Promise<void>> authenticatePkAsync(const std::string& username, const std::shared_ptr<HybridSshKeySpec>& privateKey) = 0;
+      virtual void authenticatePw(const std::string& login, const std::string& password) = 0;
+      virtual std::shared_ptr<Promise<void>> authenticatePwAsync(const std::string& login, const std::string& password) = 0;
+      virtual void authenticatePwPk(const std::string& username, const std::string& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) = 0;
+      virtual std::shared_ptr<Promise<void>> authenticatePwPkAsync(const std::string& username, const std::string& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) = 0;
+      virtual void beginAccepting(double listenPort) = 0;
+      virtual std::shared_ptr<Promise<void>> beginAcceptingAsync(double listenPort) = 0;
+      virtual void closeTunnel(bool waitForThreads) = 0;
+      virtual void connect(const std::string& hostname, double port) = 0;
+      virtual std::shared_ptr<Promise<void>> connectAsync(const std::string& hostname, double port) = 0;
+      virtual void disconnectAllClients(bool waitForThreads) = 0;
+      virtual void stopAccepting(bool waitForThread) = 0;
+      virtual void connectThroughSsh(const std::shared_ptr<HybridSshSpec>& ssh, const std::string& hostname, double port) = 0;
+      virtual std::shared_ptr<Promise<void>> connectThroughSshAsync(const std::shared_ptr<HybridSshSpec>& ssh, const std::string& hostname, double port) = 0;
+      virtual bool isSshConnected() = 0;
+      virtual std::string getCurrentState() = 0;
+      virtual void authenticateSecPw(const std::shared_ptr<HybridSecureStringSpec>& login, const std::shared_ptr<HybridSecureStringSpec>& password) = 0;
+      virtual std::shared_ptr<Promise<void>> authenticateSecPwAsync(const std::shared_ptr<HybridSecureStringSpec>& login, const std::shared_ptr<HybridSecureStringSpec>& password) = 0;
+      virtual void authenticateSecPwPk(const std::shared_ptr<HybridSecureStringSpec>& username, const std::shared_ptr<HybridSecureStringSpec>& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) = 0;
+      virtual std::shared_ptr<Promise<void>> authenticateSecPwPkAsync(const std::shared_ptr<HybridSecureStringSpec>& username, const std::shared_ptr<HybridSecureStringSpec>& password, const std::shared_ptr<HybridSshKeySpec>& privateKey) = 0;
+      virtual std::string startKeyboardAuth(const std::string& login) = 0;
+      virtual std::shared_ptr<Promise<std::string>> startKeyboardAuthAsync(const std::string& login) = 0;
+      virtual std::string continueKeyboardAuth(const std::string& response) = 0;
+      virtual std::shared_ptr<Promise<std::string>> continueKeyboardAuthAsync(const std::string& response) = 0;
+      virtual void setAllowedAlgorithms(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "SshTunnel";
+  };
+
+} // namespace margelo::nitro::chilkat