@chilkat/react-native 11.6.1

package/cpp/HybridSsh.hpp

@@ -0,0 +1,282 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Ssh: the Nitro HybridObject over Chilkat's CkSsh (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridSshSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkSsh.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridSsh final : public HybridSshSpec, public ChilkatObject<CkSsh> {
+public:
+  HybridSsh();                                  // `new Ssh()` from JS
+  explicit HybridSsh(CkSsh* 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;
+  double getAuthFailReason() override;
+  bool getCaretControl() override;
+  void setCaretControl(bool value) override;
+  double getChannelOpenFailCode() override;
+  std::string getChannelOpenFailReason() override;
+  std::string getClientIdentifier() override;
+  void setClientIdentifier(const std::string& value) override;
+  std::string getClientIpAddress() override;
+  void setClientIpAddress(const std::string& value) override;
+  double getConnectTimeoutMs() override;
+  void setConnectTimeoutMs(double value) override;
+  double getDisconnectCode() override;
+  std::string getDisconnectReason() override;
+  std::string getForceCipher() override;
+  void setForceCipher(const std::string& value) override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+  std::string getHostKeyAlg() override;
+  void setHostKeyAlg(const std::string& value) override;
+  std::string getHostKeyFingerprint() 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;
+  bool getIsConnected() override;
+  bool getKeepSessionLog() override;
+  void setKeepSessionLog(bool value) override;
+  double getMaxPacketSize() override;
+  void setMaxPacketSize(double value) override;
+  double getNumOpenChannels() override;
+  bool getPasswordChangeRequested() override;
+  bool getPreferIpv6() override;
+  void setPreferIpv6(bool value) override;
+  double getReadTimeoutMs() override;
+  void setReadTimeoutMs(double value) override;
+  std::string getReqExecCharset() override;
+  void setReqExecCharset(const std::string& value) override;
+  std::string getSessionLog() 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 getStderrToStdout() override;
+  void setStderrToStdout(bool value) override;
+  bool getTcpNoDelay() override;
+  void setTcpNoDelay(bool value) override;
+  std::string getUserAuthBanner() override;
+  void setUserAuthBanner(const std::string& value) override;
+  bool getEnableCompression() override;
+  void setEnableCompression(bool value) override;
+  bool getAbortCurrent() override;
+  void setAbortCurrent(bool value) override;
+  bool getStripColorCodes() override;
+  void setStripColorCodes(bool value) override;
+  std::string getServerIdentifier() override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+  double getClientPort() override;
+  void setClientPort(double 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;
+  bool channelIsOpen(double channelNum) override;
+  double channelPoll(double channelNum, double pollTimeoutMs) override;
+  std::shared_ptr<Promise<double>> channelPollAsync(double channelNum, double pollTimeoutMs) override;
+  double channelRead(double channelNum) override;
+  std::shared_ptr<Promise<double>> channelReadAsync(double channelNum) override;
+  double channelReadAndPoll(double channelNum, double pollTimeoutMs) override;
+  std::shared_ptr<Promise<double>> channelReadAndPollAsync(double channelNum, double pollTimeoutMs) override;
+  double channelReadAndPoll2(double channelNum, double pollTimeoutMs, double maxNumBytes) override;
+  std::shared_ptr<Promise<double>> channelReadAndPoll2Async(double channelNum, double pollTimeoutMs, double maxNumBytes) override;
+  void channelReceiveToClose(double channelNum) override;
+  std::shared_ptr<Promise<void>> channelReceiveToCloseAsync(double channelNum) override;
+  void channelReceiveUntilMatch(double channelNum, const std::string& matchPattern, const std::string& charset, bool caseSensitive) override;
+  std::shared_ptr<Promise<void>> channelReceiveUntilMatchAsync(double channelNum, const std::string& matchPattern, const std::string& charset, bool caseSensitive) override;
+  void channelReceiveUntilMatchN(double channelNum, const std::shared_ptr<HybridStringArraySpec>& matchPatterns, const std::string& charset, bool caseSensitive) override;
+  std::shared_ptr<Promise<void>> channelReceiveUntilMatchNAsync(double channelNum, const std::shared_ptr<HybridStringArraySpec>& matchPatterns, const std::string& charset, bool caseSensitive) override;
+  bool channelReceivedClose(double channelNum) override;
+  bool channelReceivedEof(double channelNum) override;
+  bool channelReceivedExitStatus(double channelNum) override;
+  void channelRelease(double channelNum) override;
+  void channelSendClose(double channelNum) override;
+  std::shared_ptr<Promise<void>> channelSendCloseAsync(double channelNum) override;
+  void channelSendEof(double channelNum) override;
+  std::shared_ptr<Promise<void>> channelSendEofAsync(double channelNum) override;
+  void channelSendString(double channelNum, const std::string& textData, const std::string& charset) override;
+  std::shared_ptr<Promise<void>> channelSendStringAsync(double channelNum, const std::string& textData, const std::string& charset) override;
+  bool checkConnection() override;
+  void clearTtyModes() override;
+  void connect(const std::string& domainName, double port) override;
+  std::shared_ptr<Promise<void>> connectAsync(const std::string& domainName, double port) 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;
+  std::string continueKeyboardAuth(const std::string& response) override;
+  std::shared_ptr<Promise<std::string>> continueKeyboardAuthAsync(const std::string& response) override;
+  void disconnect() override;
+  double getChannelExitStatus(double channelNum) override;
+  double getChannelNumber(double index) override;
+  std::string getChannelType(double index) override;
+  double getReceivedNumBytes(double channelNum) override;
+  std::string getReceivedStderrText(double channelNum, const std::string& charset) override;
+  std::string getReceivedText(double channelNum, const std::string& charset) override;
+  std::string getReceivedTextS(double channelNum, const std::string& substr, const std::string& charset) override;
+  double openCustomChannel(const std::string& channelType) override;
+  std::shared_ptr<Promise<double>> openCustomChannelAsync(const std::string& channelType) override;
+  double openDirectTcpIpChannel(const std::string& targetHostname, double targetPort) override;
+  std::shared_ptr<Promise<double>> openDirectTcpIpChannelAsync(const std::string& targetHostname, double targetPort) override;
+  double openSessionChannel() override;
+  std::shared_ptr<Promise<double>> openSessionChannelAsync() override;
+  std::string peekReceivedText(double channelNum, const std::string& charset) override;
+  void reKey() override;
+  std::shared_ptr<Promise<void>> reKeyAsync() override;
+  void sendIgnore() override;
+  std::shared_ptr<Promise<void>> sendIgnoreAsync() override;
+  void sendReqExec(double channelNum, const std::string& commandLine) override;
+  std::shared_ptr<Promise<void>> sendReqExecAsync(double channelNum, const std::string& commandLine) override;
+  void sendReqPty(double channelNum, const std::string& termType, double widthInChars, double heightInChars, double widthInPixels, double heightInPixels) override;
+  std::shared_ptr<Promise<void>> sendReqPtyAsync(double channelNum, const std::string& termType, double widthInChars, double heightInChars, double widthInPixels, double heightInPixels) override;
+  void sendReqSetEnv(double channelNum, const std::string& name, const std::string& value) override;
+  std::shared_ptr<Promise<void>> sendReqSetEnvAsync(double channelNum, const std::string& name, const std::string& value) override;
+  void sendReqShell(double channelNum) override;
+  std::shared_ptr<Promise<void>> sendReqShellAsync(double channelNum) override;
+  void sendReqSignal(double channelNum, const std::string& signalName) override;
+  std::shared_ptr<Promise<void>> sendReqSignalAsync(double channelNum, const std::string& signalName) override;
+  void sendReqSubsystem(double channelNum, const std::string& subsystemName) override;
+  std::shared_ptr<Promise<void>> sendReqSubsystemAsync(double channelNum, const std::string& subsystemName) override;
+  void sendReqWindowChange(double channelNum, double widthInChars, double heightInRows, double pixWidth, double pixHeight) override;
+  std::shared_ptr<Promise<void>> sendReqWindowChangeAsync(double channelNum, double widthInChars, double heightInRows, double pixWidth, double pixHeight) override;
+  void sendReqX11Forwarding(double channelNum, bool singleConnection, const std::string& authProt, const std::string& authCookie, double screenNum) override;
+  std::shared_ptr<Promise<void>> sendReqX11ForwardingAsync(double channelNum, bool singleConnection, const std::string& authProt, const std::string& authCookie, double screenNum) override;
+  void sendReqXonXoff(double channelNum, bool clientCanDo) override;
+  std::shared_ptr<Promise<void>> sendReqXonXoffAsync(double channelNum, bool clientCanDo) override;
+  void setTtyMode(const std::string& ttyName, double ttyValue) override;
+  std::string startKeyboardAuth(const std::string& login) override;
+  std::shared_ptr<Promise<std::string>> startKeyboardAuthAsync(const std::string& login) override;
+  double waitForChannelMessage(double pollTimeoutMs) override;
+  std::shared_ptr<Promise<double>> waitForChannelMessageAsync(double pollTimeoutMs) override;
+  std::string quickCommand(const std::string& command, const std::string& charset) override;
+  std::shared_ptr<Promise<std::string>> quickCommandAsync(const std::string& command, const std::string& charset) override;
+  double quickShell() override;
+  std::shared_ptr<Promise<double>> quickShellAsync() override;
+  double quickCmdSend(const std::string& command) override;
+  std::shared_ptr<Promise<double>> quickCmdSendAsync(const std::string& command) override;
+  double quickCmdCheck(double pollTimeoutMs) override;
+  std::shared_ptr<Promise<double>> quickCmdCheckAsync(double pollTimeoutMs) 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 getAuthMethods() override;
+  std::shared_ptr<Promise<std::string>> getAuthMethodsAsync() override;
+  std::string getHostKeyFP(const std::string& hashAlg, bool includeKeyType, bool includeHashName) override;
+  void setAllowedAlgorithms(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void getReceivedSb(double channelNum, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb) 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);
+  bool channelIsOpen_impl(double channelNum);
+  double channelPoll_impl(double channelNum, double pollTimeoutMs);
+  double channelRead_impl(double channelNum);
+  double channelReadAndPoll_impl(double channelNum, double pollTimeoutMs);
+  double channelReadAndPoll2_impl(double channelNum, double pollTimeoutMs, double maxNumBytes);
+  void channelReceiveToClose_impl(double channelNum);
+  void channelReceiveUntilMatch_impl(double channelNum, const std::string& matchPattern, const std::string& charset, bool caseSensitive);
+  void channelReceiveUntilMatchN_impl(double channelNum, const std::shared_ptr<HybridStringArraySpec>& matchPatterns, const std::string& charset, bool caseSensitive);
+  bool channelReceivedClose_impl(double channelNum);
+  bool channelReceivedEof_impl(double channelNum);
+  bool channelReceivedExitStatus_impl(double channelNum);
+  void channelRelease_impl(double channelNum);
+  void channelSendClose_impl(double channelNum);
+  void channelSendEof_impl(double channelNum);
+  void channelSendString_impl(double channelNum, const std::string& textData, const std::string& charset);
+  bool checkConnection_impl();
+  void clearTtyModes_impl();
+  void connect_impl(const std::string& domainName, double port);
+  void connectThroughSsh_impl(const std::shared_ptr<HybridSshSpec>& ssh, const std::string& hostname, double port);
+  std::string continueKeyboardAuth_impl(const std::string& response);
+  void disconnect_impl();
+  double getChannelExitStatus_impl(double channelNum);
+  double getChannelNumber_impl(double index);
+  std::string getChannelType_impl(double index);
+  double getReceivedNumBytes_impl(double channelNum);
+  std::string getReceivedStderrText_impl(double channelNum, const std::string& charset);
+  std::string getReceivedText_impl(double channelNum, const std::string& charset);
+  std::string getReceivedTextS_impl(double channelNum, const std::string& substr, const std::string& charset);
+  double openCustomChannel_impl(const std::string& channelType);
+  double openDirectTcpIpChannel_impl(const std::string& targetHostname, double targetPort);
+  double openSessionChannel_impl();
+  std::string peekReceivedText_impl(double channelNum, const std::string& charset);
+  void reKey_impl();
+  void sendIgnore_impl();
+  void sendReqExec_impl(double channelNum, const std::string& commandLine);
+  void sendReqPty_impl(double channelNum, const std::string& termType, double widthInChars, double heightInChars, double widthInPixels, double heightInPixels);
+  void sendReqSetEnv_impl(double channelNum, const std::string& name, const std::string& value);
+  void sendReqShell_impl(double channelNum);
+  void sendReqSignal_impl(double channelNum, const std::string& signalName);
+  void sendReqSubsystem_impl(double channelNum, const std::string& subsystemName);
+  void sendReqWindowChange_impl(double channelNum, double widthInChars, double heightInRows, double pixWidth, double pixHeight);
+  void sendReqX11Forwarding_impl(double channelNum, bool singleConnection, const std::string& authProt, const std::string& authCookie, double screenNum);
+  void sendReqXonXoff_impl(double channelNum, bool clientCanDo);
+  void setTtyMode_impl(const std::string& ttyName, double ttyValue);
+  std::string startKeyboardAuth_impl(const std::string& login);
+  double waitForChannelMessage_impl(double pollTimeoutMs);
+  std::string quickCommand_impl(const std::string& command, const std::string& charset);
+  double quickShell_impl();
+  double quickCmdSend_impl(const std::string& command);
+  double quickCmdCheck_impl(double pollTimeoutMs);
+  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 getAuthMethods_impl();
+  std::string getHostKeyFP_impl(const std::string& hashAlg, bool includeKeyType, bool includeHashName);
+  void setAllowedAlgorithms_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void getReceivedSb_impl(double channelNum, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sb);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridSshKey.cpp

@@ -0,0 +1,310 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridSshKey.hpp"
+#include "HybridPkcs11.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridSshKey::HybridSshKey()
+    : HybridObject(HybridSshKeySpec::TAG), ChilkatObject<CkSshKey>("SshKey", CkSshKey::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridSshKey::HybridSshKey(CkSshKey* owned)
+    : HybridObject(HybridSshKeySpec::TAG), ChilkatObject<CkSshKey>("SshKey", owned) {
+  init();
+}
+
+void HybridSshKey::init() {
+}
+
+void HybridSshKey::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridSshKey::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSshKey::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSshKey::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSshKey::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSshKey::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridSshKey::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridSshKey::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridSshKey::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridSshKey::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridSshKey::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridSshKey::getComment() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Comment(_s);
+  return rt::stdString(_s);
+}
+void HybridSshKey::setComment(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "comment");
+  this->ck().put_Comment(value.c_str());
+}
+bool HybridSshKey::getIsDsaKey() {
+  this->beginCall();
+  return this->ck().get_IsDsaKey();
+}
+bool HybridSshKey::getIsPrivateKey() {
+  this->beginCall();
+  return this->ck().get_IsPrivateKey();
+}
+bool HybridSshKey::getIsRsaKey() {
+  this->beginCall();
+  return this->ck().get_IsRsaKey();
+}
+std::string HybridSshKey::getPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Password(_s);
+  return rt::stdString(_s);
+}
+void HybridSshKey::setPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "password");
+  this->ck().put_Password(value.c_str());
+}
+std::string HybridSshKey::getKeyType() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_KeyType(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSshKey::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridSshKey::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridSshKey::fromOpenSshPrivateKey(const std::string& keyStr) {
+  this->beginCall();
+  fromOpenSshPrivateKey_impl(keyStr);
+}
+void HybridSshKey::fromOpenSshPrivateKey_impl(const std::string& keyStr) {
+  rt::checkNoNul(keyStr, "keyStr");
+  if (!this->ck().FromOpenSshPrivateKey(keyStr.c_str())) throw this->fail("fromOpenSshPrivateKey");
+}
+
+void HybridSshKey::fromOpenSshPublicKey(const std::string& keyStr) {
+  this->beginCall();
+  fromOpenSshPublicKey_impl(keyStr);
+}
+void HybridSshKey::fromOpenSshPublicKey_impl(const std::string& keyStr) {
+  rt::checkNoNul(keyStr, "keyStr");
+  if (!this->ck().FromOpenSshPublicKey(keyStr.c_str())) throw this->fail("fromOpenSshPublicKey");
+}
+
+void HybridSshKey::fromPuttyPrivateKey(const std::string& keyStr) {
+  this->beginCall();
+  fromPuttyPrivateKey_impl(keyStr);
+}
+void HybridSshKey::fromPuttyPrivateKey_impl(const std::string& keyStr) {
+  rt::checkNoNul(keyStr, "keyStr");
+  if (!this->ck().FromPuttyPrivateKey(keyStr.c_str())) throw this->fail("fromPuttyPrivateKey");
+}
+
+void HybridSshKey::fromRfc4716PublicKey(const std::string& keyStr) {
+  this->beginCall();
+  fromRfc4716PublicKey_impl(keyStr);
+}
+void HybridSshKey::fromRfc4716PublicKey_impl(const std::string& keyStr) {
+  rt::checkNoNul(keyStr, "keyStr");
+  if (!this->ck().FromRfc4716PublicKey(keyStr.c_str())) throw this->fail("fromRfc4716PublicKey");
+}
+
+void HybridSshKey::fromXml(const std::string& xmlKey) {
+  this->beginCall();
+  fromXml_impl(xmlKey);
+}
+void HybridSshKey::fromXml_impl(const std::string& xmlKey) {
+  rt::checkNoNul(xmlKey, "xmlKey");
+  if (!this->ck().FromXml(xmlKey.c_str())) throw this->fail("fromXml");
+}
+
+std::string HybridSshKey::genFingerprint() {
+  this->beginCall();
+  return genFingerprint_impl();
+}
+std::string HybridSshKey::genFingerprint_impl() {
+  CkString _out;
+  if (!this->ck().GenFingerprint(_out)) throw this->fail("genFingerprint");
+  return rt::stdString(_out);
+}
+
+void HybridSshKey::generateDsaKey(double numBits) {
+  this->beginCall();
+  generateDsaKey_impl(numBits);
+}
+void HybridSshKey::generateDsaKey_impl(double numBits) {
+  if (!this->ck().GenerateDsaKey(rt::toInt(numBits, "numBits"))) throw this->fail("generateDsaKey");
+}
+
+void HybridSshKey::generateRsaKey(double numBits, double exponent) {
+  this->beginCall();
+  generateRsaKey_impl(numBits, exponent);
+}
+void HybridSshKey::generateRsaKey_impl(double numBits, double exponent) {
+  if (!this->ck().GenerateRsaKey(rt::toInt(numBits, "numBits"), rt::toInt(exponent, "exponent"))) throw this->fail("generateRsaKey");
+}
+
+std::string HybridSshKey::loadText(const std::string& filename) {
+  this->beginCall();
+  return loadText_impl(filename);
+}
+std::string HybridSshKey::loadText_impl(const std::string& filename) {
+  rt::checkNoNul(filename, "filename");
+  CkString _out;
+  if (!this->ck().LoadText(filename.c_str(), _out)) throw this->fail("loadText");
+  return rt::stdString(_out);
+}
+
+void HybridSshKey::saveText(const std::string& strToSave, const std::string& filename) {
+  this->beginCall();
+  saveText_impl(strToSave, filename);
+}
+void HybridSshKey::saveText_impl(const std::string& strToSave, const std::string& filename) {
+  rt::checkNoNul(strToSave, "strToSave");
+  rt::checkNoNul(filename, "filename");
+  if (!this->ck().SaveText(strToSave.c_str(), filename.c_str())) throw this->fail("saveText");
+}
+
+std::string HybridSshKey::toOpenSshPrivateKey(bool bEncrypt) {
+  this->beginCall();
+  return toOpenSshPrivateKey_impl(bEncrypt);
+}
+std::string HybridSshKey::toOpenSshPrivateKey_impl(bool bEncrypt) {
+  CkString _out;
+  if (!this->ck().ToOpenSshPrivateKey(bEncrypt, _out)) throw this->fail("toOpenSshPrivateKey");
+  return rt::stdString(_out);
+}
+
+std::string HybridSshKey::toOpenSshPublicKey() {
+  this->beginCall();
+  return toOpenSshPublicKey_impl();
+}
+std::string HybridSshKey::toOpenSshPublicKey_impl() {
+  CkString _out;
+  if (!this->ck().ToOpenSshPublicKey(_out)) throw this->fail("toOpenSshPublicKey");
+  return rt::stdString(_out);
+}
+
+std::string HybridSshKey::toPuttyPrivateKey(bool bEncrypt) {
+  this->beginCall();
+  return toPuttyPrivateKey_impl(bEncrypt);
+}
+std::string HybridSshKey::toPuttyPrivateKey_impl(bool bEncrypt) {
+  CkString _out;
+  if (!this->ck().ToPuttyPrivateKey(bEncrypt, _out)) throw this->fail("toPuttyPrivateKey");
+  return rt::stdString(_out);
+}
+
+std::string HybridSshKey::toRfc4716PublicKey() {
+  this->beginCall();
+  return toRfc4716PublicKey_impl();
+}
+std::string HybridSshKey::toRfc4716PublicKey_impl() {
+  CkString _out;
+  if (!this->ck().ToRfc4716PublicKey(_out)) throw this->fail("toRfc4716PublicKey");
+  return rt::stdString(_out);
+}
+
+std::string HybridSshKey::toXml() {
+  this->beginCall();
+  return toXml_impl();
+}
+std::string HybridSshKey::toXml_impl() {
+  CkString _out;
+  if (!this->ck().ToXml(_out)) throw this->fail("toXml");
+  return rt::stdString(_out);
+}
+
+void HybridSshKey::generateEd25519Key() {
+  this->beginCall();
+  generateEd25519Key_impl();
+}
+void HybridSshKey::generateEd25519Key_impl() {
+  if (!this->ck().GenerateEd25519Key()) throw this->fail("generateEd25519Key");
+}
+
+void HybridSshKey::generateEcdsaKey(const std::string& curveName) {
+  this->beginCall();
+  generateEcdsaKey_impl(curveName);
+}
+void HybridSshKey::generateEcdsaKey_impl(const std::string& curveName) {
+  rt::checkNoNul(curveName, "curveName");
+  if (!this->ck().GenerateEcdsaKey(curveName.c_str())) throw this->fail("generateEcdsaKey");
+}
+
+void HybridSshKey::usePkcs11(const std::shared_ptr<HybridPkcs11Spec>& session, double privKeyHandle, double pubKeyHandle, const std::string& keyType) {
+  this->beginCall();
+  usePkcs11_impl(session, privKeyHandle, pubKeyHandle, keyType);
+}
+void HybridSshKey::usePkcs11_impl(const std::shared_ptr<HybridPkcs11Spec>& session, double privKeyHandle, double pubKeyHandle, const std::string& keyType) {
+  rt::checkNoNul(keyType, "keyType");
+  if (!this->ck().UsePkcs11(rt::implOf<HybridPkcs11>(session, "session").ck(), rt::toULong(privKeyHandle, "privKeyHandle"), rt::toULong(pubKeyHandle, "pubKeyHandle"), keyType.c_str())) throw this->fail("usePkcs11");
+}
+
+void HybridSshKey::useSshCertificate(const std::string& sshCert) {
+  this->beginCall();
+  useSshCertificate_impl(sshCert);
+}
+void HybridSshKey::useSshCertificate_impl(const std::string& sshCert) {
+  rt::checkNoNul(sshCert, "sshCert");
+  if (!this->ck().UseSshCertificate(sshCert.c_str())) throw this->fail("useSshCertificate");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridSshKey.hpp

@@ -0,0 +1,83 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// SshKey: the Nitro HybridObject over Chilkat's CkSshKey (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridSshKeySpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkSshKey.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridSshKey final : public HybridSshKeySpec, public ChilkatObject<CkSshKey> {
+public:
+  HybridSshKey();                                  // `new SshKey()` from JS
+  explicit HybridSshKey(CkSshKey* 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 getComment() override;
+  void setComment(const std::string& value) override;
+  bool getIsDsaKey() override;
+  bool getIsPrivateKey() override;
+  bool getIsRsaKey() override;
+  std::string getPassword() override;
+  void setPassword(const std::string& value) override;
+  std::string getKeyType() override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+
+  // ---- Methods ----
+  void fromOpenSshPrivateKey(const std::string& keyStr) override;
+  void fromOpenSshPublicKey(const std::string& keyStr) override;
+  void fromPuttyPrivateKey(const std::string& keyStr) override;
+  void fromRfc4716PublicKey(const std::string& keyStr) override;
+  void fromXml(const std::string& xmlKey) override;
+  std::string genFingerprint() override;
+  void generateDsaKey(double numBits) override;
+  void generateRsaKey(double numBits, double exponent) override;
+  std::string loadText(const std::string& filename) override;
+  void saveText(const std::string& strToSave, const std::string& filename) override;
+  std::string toOpenSshPrivateKey(bool bEncrypt) override;
+  std::string toOpenSshPublicKey() override;
+  std::string toPuttyPrivateKey(bool bEncrypt) override;
+  std::string toRfc4716PublicKey() override;
+  std::string toXml() override;
+  void generateEd25519Key() override;
+  void generateEcdsaKey(const std::string& curveName) override;
+  void usePkcs11(const std::shared_ptr<HybridPkcs11Spec>& session, double privKeyHandle, double pubKeyHandle, const std::string& keyType) override;
+  void useSshCertificate(const std::string& sshCert) override;
+
+private:
+  void init();
+  void fromOpenSshPrivateKey_impl(const std::string& keyStr);
+  void fromOpenSshPublicKey_impl(const std::string& keyStr);
+  void fromPuttyPrivateKey_impl(const std::string& keyStr);
+  void fromRfc4716PublicKey_impl(const std::string& keyStr);
+  void fromXml_impl(const std::string& xmlKey);
+  std::string genFingerprint_impl();
+  void generateDsaKey_impl(double numBits);
+  void generateRsaKey_impl(double numBits, double exponent);
+  std::string loadText_impl(const std::string& filename);
+  void saveText_impl(const std::string& strToSave, const std::string& filename);
+  std::string toOpenSshPrivateKey_impl(bool bEncrypt);
+  std::string toOpenSshPublicKey_impl();
+  std::string toPuttyPrivateKey_impl(bool bEncrypt);
+  std::string toRfc4716PublicKey_impl();
+  std::string toXml_impl();
+  void generateEd25519Key_impl();
+  void generateEcdsaKey_impl(const std::string& curveName);
+  void usePkcs11_impl(const std::shared_ptr<HybridPkcs11Spec>& session, double privKeyHandle, double pubKeyHandle, const std::string& keyType);
+  void useSshCertificate_impl(const std::string& sshCert);
+};
+
+} // namespace margelo::nitro::chilkat