@chilkat/react-native 11.6.1

package/cpp/HybridScMinidriver.hpp

@@ -0,0 +1,88 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// ScMinidriver: the Nitro HybridObject over Chilkat's CkScMinidriver (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridScMinidriverSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkScMinidriver.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridScMinidriver final : public HybridScMinidriverSpec, public ChilkatObject<CkScMinidriver> {
+public:
+  HybridScMinidriver();                                  // `new ScMinidriver()` from JS
+  explicit HybridScMinidriver(CkScMinidriver* 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 getAtr() override;
+  std::string getCardName() override;
+  std::string getRsaPaddingScheme() override;
+  void setRsaPaddingScheme(const std::string& value) override;
+  std::string getRsaPaddingHash() override;
+  void setRsaPaddingHash(const std::string& value) override;
+  double getMaxContainers() override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+
+  // ---- Methods ----
+  void acquireContext(const std::string& readerName) override;
+  void deleteContext() override;
+  void enumFiles(const std::string& dirName, const std::shared_ptr<HybridStringTableSpec>& st) override;
+  void readFile(const std::string& dirName, const std::string& fileName, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void getCardProperties(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  double pinAuthenticate(const std::string& pinId, const std::string& pin) override;
+  void pinDeauthenticate(const std::string& pinId) override;
+  double pinChange(const std::string& pinId, const std::string& currentPin, const std::string& newPin) override;
+  void signData(double containerIndex, const std::string& keySpec, const std::string& hashDataAlg, const std::shared_ptr<HybridBinDataSpec>& bdData, const std::shared_ptr<HybridBinDataSpec>& bdSignedData) override;
+  void getContainerKeys(double containerIndex, const std::shared_ptr<HybridPublicKeySpec>& sigKey, const std::shared_ptr<HybridPublicKeySpec>& kexKey) override;
+  void generateKey(double containerIndex, const std::string& keySpec, const std::string& keyType, double keySize, const std::string& pinId) override;
+  void importKey(double containerIndex, const std::string& keySpec, const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::string& pinId) override;
+  void deleteKeyContainer(double containerIndex) override;
+  void getCspContainerMap(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void listCerts(const std::string& certPart, const std::shared_ptr<HybridStringTableSpec>& st) override;
+  void importCert(const std::shared_ptr<HybridCertSpec>& cert, double containerIndex, const std::string& keySpec, const std::string& pinId) override;
+  void writeFile(const std::string& dirName, const std::string& fileName, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void getCert(double containerIndex, const std::string& keySpec, const std::shared_ptr<HybridCertSpec>& cert) override;
+  void findCert(const std::string& certPart, const std::string& partValue, const std::shared_ptr<HybridCertSpec>& cert) override;
+  double pinAuthenticateHex(const std::string& pinId, const std::string& pin) override;
+  void deleteCert(const std::shared_ptr<HybridCertSpec>& cert, bool delPrivKey) override;
+  void cardDeleteFile(const std::string& dirName, const std::string& fileName) override;
+
+private:
+  void init();
+  void acquireContext_impl(const std::string& readerName);
+  void deleteContext_impl();
+  void enumFiles_impl(const std::string& dirName, const std::shared_ptr<HybridStringTableSpec>& st);
+  void readFile_impl(const std::string& dirName, const std::string& fileName, const std::shared_ptr<HybridBinDataSpec>& bd);
+  void getCardProperties_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  double pinAuthenticate_impl(const std::string& pinId, const std::string& pin);
+  void pinDeauthenticate_impl(const std::string& pinId);
+  double pinChange_impl(const std::string& pinId, const std::string& currentPin, const std::string& newPin);
+  void signData_impl(double containerIndex, const std::string& keySpec, const std::string& hashDataAlg, const std::shared_ptr<HybridBinDataSpec>& bdData, const std::shared_ptr<HybridBinDataSpec>& bdSignedData);
+  void getContainerKeys_impl(double containerIndex, const std::shared_ptr<HybridPublicKeySpec>& sigKey, const std::shared_ptr<HybridPublicKeySpec>& kexKey);
+  void generateKey_impl(double containerIndex, const std::string& keySpec, const std::string& keyType, double keySize, const std::string& pinId);
+  void importKey_impl(double containerIndex, const std::string& keySpec, const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::string& pinId);
+  void deleteKeyContainer_impl(double containerIndex);
+  void getCspContainerMap_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void listCerts_impl(const std::string& certPart, const std::shared_ptr<HybridStringTableSpec>& st);
+  void importCert_impl(const std::shared_ptr<HybridCertSpec>& cert, double containerIndex, const std::string& keySpec, const std::string& pinId);
+  void writeFile_impl(const std::string& dirName, const std::string& fileName, const std::shared_ptr<HybridBinDataSpec>& bd);
+  void getCert_impl(double containerIndex, const std::string& keySpec, const std::shared_ptr<HybridCertSpec>& cert);
+  void findCert_impl(const std::string& certPart, const std::string& partValue, const std::shared_ptr<HybridCertSpec>& cert);
+  double pinAuthenticateHex_impl(const std::string& pinId, const std::string& pin);
+  void deleteCert_impl(const std::shared_ptr<HybridCertSpec>& cert, bool delPrivKey);
+  void cardDeleteFile_impl(const std::string& dirName, const std::string& fileName);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridScp.cpp

@@ -0,0 +1,398 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridScp.hpp"
+#include "HybridBinData.hpp"
+#include "HybridSsh.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridScp::HybridScp()
+    : HybridObject(HybridScpSpec::TAG), ChilkatObject<CkScp>("Scp", CkScp::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridScp::HybridScp(CkScp* owned)
+    : HybridObject(HybridScpSpec::TAG), ChilkatObject<CkScp>("Scp", owned) {
+  init();
+}
+
+void HybridScp::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridScp::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridScp::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridScp::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridScp::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridScp::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridScp::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridScp::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridScp::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridScp::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridScp::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridScp::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridScp::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridScp::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+double HybridScp::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridScp::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+double HybridScp::getPercentDoneScale() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_PercentDoneScale());
+}
+void HybridScp::setPercentDoneScale(double value) {
+  this->beginCall();
+  this->ck().put_PercentDoneScale(rt::toInt(value, "percentDoneScale"));
+}
+std::string HybridScp::getSyncMustMatch() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SyncMustMatch(_s);
+  return rt::stdString(_s);
+}
+void HybridScp::setSyncMustMatch(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "syncMustMatch");
+  this->ck().put_SyncMustMatch(value.c_str());
+}
+std::string HybridScp::getSyncMustMatchDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SyncMustMatchDir(_s);
+  return rt::stdString(_s);
+}
+void HybridScp::setSyncMustMatchDir(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "syncMustMatchDir");
+  this->ck().put_SyncMustMatchDir(value.c_str());
+}
+std::string HybridScp::getSyncMustNotMatch() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SyncMustNotMatch(_s);
+  return rt::stdString(_s);
+}
+void HybridScp::setSyncMustNotMatch(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "syncMustNotMatch");
+  this->ck().put_SyncMustNotMatch(value.c_str());
+}
+std::string HybridScp::getSyncMustNotMatchDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SyncMustNotMatchDir(_s);
+  return rt::stdString(_s);
+}
+void HybridScp::setSyncMustNotMatchDir(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "syncMustNotMatchDir");
+  this->ck().put_SyncMustNotMatchDir(value.c_str());
+}
+std::string HybridScp::getSyncedFiles() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SyncedFiles(_s);
+  return rt::stdString(_s);
+}
+void HybridScp::setSyncedFiles(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "syncedFiles");
+  this->ck().put_SyncedFiles(value.c_str());
+}
+std::string HybridScp::getUnixPermOverride() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UnixPermOverride(_s);
+  return rt::stdString(_s);
+}
+void HybridScp::setUnixPermOverride(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "unixPermOverride");
+  this->ck().put_UnixPermOverride(value.c_str());
+}
+std::string HybridScp::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridScp::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+std::string HybridScp::getSendEnv() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SendEnv(_s);
+  return rt::stdString(_s);
+}
+void HybridScp::setSendEnv(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "sendEnv");
+  this->ck().put_SendEnv(value.c_str());
+}
+
+// ---- Methods ----
+
+std::string HybridScp::downloadBinaryEncoded(const std::string& remotePath, const std::string& encoding) {
+  this->beginCall();
+  return downloadBinaryEncoded_impl(remotePath, encoding);
+}
+std::string HybridScp::downloadBinaryEncoded_impl(const std::string& remotePath, const std::string& encoding) {
+  rt::checkNoNul(remotePath, "remotePath");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().DownloadBinaryEncoded(remotePath.c_str(), encoding.c_str(), _out)) throw this->fail("downloadBinaryEncoded");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridScp::downloadBinaryEncodedAsync(const std::string& remotePath, const std::string& encoding) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridScp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Scp.downloadBinaryEncodedAsync", std::move(_parts), [_self, remotePath, encoding]() {
+    return _self->downloadBinaryEncoded_impl(remotePath, encoding);
+  });
+}
+
+void HybridScp::downloadFile(const std::string& remotePath, const std::string& localPath) {
+  this->beginCall();
+  downloadFile_impl(remotePath, localPath);
+}
+void HybridScp::downloadFile_impl(const std::string& remotePath, const std::string& localPath) {
+  rt::checkNoNul(remotePath, "remotePath");
+  rt::checkNoNul(localPath, "localPath");
+  if (!this->ck().DownloadFile(remotePath.c_str(), localPath.c_str())) throw this->fail("downloadFile");
+}
+std::shared_ptr<Promise<void>> HybridScp::downloadFileAsync(const std::string& remotePath, const std::string& localPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridScp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Scp.downloadFileAsync", std::move(_parts), [_self, remotePath, localPath]() {
+    _self->downloadFile_impl(remotePath, localPath);
+  });
+}
+
+std::string HybridScp::downloadString(const std::string& remotePath, const std::string& charset) {
+  this->beginCall();
+  return downloadString_impl(remotePath, charset);
+}
+std::string HybridScp::downloadString_impl(const std::string& remotePath, const std::string& charset) {
+  rt::checkNoNul(remotePath, "remotePath");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().DownloadString(remotePath.c_str(), charset.c_str(), _out)) throw this->fail("downloadString");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridScp::downloadStringAsync(const std::string& remotePath, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridScp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Scp.downloadStringAsync", std::move(_parts), [_self, remotePath, charset]() {
+    return _self->downloadString_impl(remotePath, charset);
+  });
+}
+
+void HybridScp::syncTreeDownload(const std::string& remoteRoot, const std::string& localRoot, double mode, bool bRecurse) {
+  this->beginCall();
+  syncTreeDownload_impl(remoteRoot, localRoot, mode, bRecurse);
+}
+void HybridScp::syncTreeDownload_impl(const std::string& remoteRoot, const std::string& localRoot, double mode, bool bRecurse) {
+  rt::checkNoNul(remoteRoot, "remoteRoot");
+  rt::checkNoNul(localRoot, "localRoot");
+  if (!this->ck().SyncTreeDownload(remoteRoot.c_str(), localRoot.c_str(), rt::toInt(mode, "mode"), bRecurse)) throw this->fail("syncTreeDownload");
+}
+std::shared_ptr<Promise<void>> HybridScp::syncTreeDownloadAsync(const std::string& remoteRoot, const std::string& localRoot, double mode, bool bRecurse) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridScp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Scp.syncTreeDownloadAsync", std::move(_parts), [_self, remoteRoot, localRoot, mode, bRecurse]() {
+    _self->syncTreeDownload_impl(remoteRoot, localRoot, mode, bRecurse);
+  });
+}
+
+void HybridScp::syncTreeUpload(const std::string& localBaseDir, const std::string& remoteBaseDir, double mode, bool bRecurse) {
+  this->beginCall();
+  syncTreeUpload_impl(localBaseDir, remoteBaseDir, mode, bRecurse);
+}
+void HybridScp::syncTreeUpload_impl(const std::string& localBaseDir, const std::string& remoteBaseDir, double mode, bool bRecurse) {
+  rt::checkNoNul(localBaseDir, "localBaseDir");
+  rt::checkNoNul(remoteBaseDir, "remoteBaseDir");
+  if (!this->ck().SyncTreeUpload(localBaseDir.c_str(), remoteBaseDir.c_str(), rt::toInt(mode, "mode"), bRecurse)) throw this->fail("syncTreeUpload");
+}
+std::shared_ptr<Promise<void>> HybridScp::syncTreeUploadAsync(const std::string& localBaseDir, const std::string& remoteBaseDir, double mode, bool bRecurse) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridScp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Scp.syncTreeUploadAsync", std::move(_parts), [_self, localBaseDir, remoteBaseDir, mode, bRecurse]() {
+    _self->syncTreeUpload_impl(localBaseDir, remoteBaseDir, mode, bRecurse);
+  });
+}
+
+void HybridScp::uploadBinaryEncoded(const std::string& remotePath, const std::string& encodedData, const std::string& encoding) {
+  this->beginCall();
+  uploadBinaryEncoded_impl(remotePath, encodedData, encoding);
+}
+void HybridScp::uploadBinaryEncoded_impl(const std::string& remotePath, const std::string& encodedData, const std::string& encoding) {
+  rt::checkNoNul(remotePath, "remotePath");
+  rt::checkNoNul(encodedData, "encodedData");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().UploadBinaryEncoded(remotePath.c_str(), encodedData.c_str(), encoding.c_str())) throw this->fail("uploadBinaryEncoded");
+}
+std::shared_ptr<Promise<void>> HybridScp::uploadBinaryEncodedAsync(const std::string& remotePath, const std::string& encodedData, const std::string& encoding) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridScp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Scp.uploadBinaryEncodedAsync", std::move(_parts), [_self, remotePath, encodedData, encoding]() {
+    _self->uploadBinaryEncoded_impl(remotePath, encodedData, encoding);
+  });
+}
+
+void HybridScp::uploadFile(const std::string& localPath, const std::string& remotePath) {
+  this->beginCall();
+  uploadFile_impl(localPath, remotePath);
+}
+void HybridScp::uploadFile_impl(const std::string& localPath, const std::string& remotePath) {
+  rt::checkNoNul(localPath, "localPath");
+  rt::checkNoNul(remotePath, "remotePath");
+  if (!this->ck().UploadFile(localPath.c_str(), remotePath.c_str())) throw this->fail("uploadFile");
+}
+std::shared_ptr<Promise<void>> HybridScp::uploadFileAsync(const std::string& localPath, const std::string& remotePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridScp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Scp.uploadFileAsync", std::move(_parts), [_self, localPath, remotePath]() {
+    _self->uploadFile_impl(localPath, remotePath);
+  });
+}
+
+void HybridScp::uploadString(const std::string& remotePath, const std::string& textData, const std::string& charset) {
+  this->beginCall();
+  uploadString_impl(remotePath, textData, charset);
+}
+void HybridScp::uploadString_impl(const std::string& remotePath, const std::string& textData, const std::string& charset) {
+  rt::checkNoNul(remotePath, "remotePath");
+  rt::checkNoNul(textData, "textData");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().UploadString(remotePath.c_str(), textData.c_str(), charset.c_str())) throw this->fail("uploadString");
+}
+std::shared_ptr<Promise<void>> HybridScp::uploadStringAsync(const std::string& remotePath, const std::string& textData, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridScp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Scp.uploadStringAsync", std::move(_parts), [_self, remotePath, textData, charset]() {
+    _self->uploadString_impl(remotePath, textData, charset);
+  });
+}
+
+void HybridScp::useSsh(const std::shared_ptr<HybridSshSpec>& sshConnection) {
+  this->beginCall();
+  useSsh_impl(sshConnection);
+}
+void HybridScp::useSsh_impl(const std::shared_ptr<HybridSshSpec>& sshConnection) {
+  if (!this->ck().UseSsh(rt::implOf<HybridSsh>(sshConnection, "sshConnection").ck())) throw this->fail("useSsh");
+}
+
+void HybridScp::downloadBd(const std::string& remotePath, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  downloadBd_impl(remotePath, bd);
+}
+void HybridScp::downloadBd_impl(const std::string& remotePath, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(remotePath, "remotePath");
+  if (!this->ck().DownloadBd(remotePath.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("downloadBd");
+}
+std::shared_ptr<Promise<void>> HybridScp::downloadBdAsync(const std::string& remotePath, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridScp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("Scp.downloadBdAsync", std::move(_parts), [_self, remotePath, bd]() {
+    _self->downloadBd_impl(remotePath, bd);
+  });
+}
+
+void HybridScp::uploadBd(const std::string& remotePath, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  uploadBd_impl(remotePath, bd);
+}
+void HybridScp::uploadBd_impl(const std::string& remotePath, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(remotePath, "remotePath");
+  if (!this->ck().UploadBd(remotePath.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("uploadBd");
+}
+std::shared_ptr<Promise<void>> HybridScp::uploadBdAsync(const std::string& remotePath, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridScp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("Scp.uploadBdAsync", std::move(_parts), [_self, remotePath, bd]() {
+    _self->uploadBd_impl(remotePath, bd);
+  });
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridScp::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridScp::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridScp::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridScp::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridScp::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridScp.hpp

@@ -0,0 +1,96 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Scp: the Nitro HybridObject over Chilkat's CkScp (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridScpSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkScp.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridScp final : public HybridScpSpec, public ChilkatObject<CkScp> {
+public:
+  HybridScp();                                  // `new Scp()` from JS
+  explicit HybridScp(CkScp* 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;
+  bool getAbortCurrent() override;
+  void setAbortCurrent(bool value) override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+  double getPercentDoneScale() override;
+  void setPercentDoneScale(double value) override;
+  std::string getSyncMustMatch() override;
+  void setSyncMustMatch(const std::string& value) override;
+  std::string getSyncMustMatchDir() override;
+  void setSyncMustMatchDir(const std::string& value) override;
+  std::string getSyncMustNotMatch() override;
+  void setSyncMustNotMatch(const std::string& value) override;
+  std::string getSyncMustNotMatchDir() override;
+  void setSyncMustNotMatchDir(const std::string& value) override;
+  std::string getSyncedFiles() override;
+  void setSyncedFiles(const std::string& value) override;
+  std::string getUnixPermOverride() override;
+  void setUnixPermOverride(const std::string& value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+  std::string getSendEnv() override;
+  void setSendEnv(const std::string& value) override;
+
+  // ---- Methods ----
+  std::string downloadBinaryEncoded(const std::string& remotePath, const std::string& encoding) override;
+  std::shared_ptr<Promise<std::string>> downloadBinaryEncodedAsync(const std::string& remotePath, const std::string& encoding) override;
+  void downloadFile(const std::string& remotePath, const std::string& localPath) override;
+  std::shared_ptr<Promise<void>> downloadFileAsync(const std::string& remotePath, const std::string& localPath) override;
+  std::string downloadString(const std::string& remotePath, const std::string& charset) override;
+  std::shared_ptr<Promise<std::string>> downloadStringAsync(const std::string& remotePath, const std::string& charset) override;
+  void syncTreeDownload(const std::string& remoteRoot, const std::string& localRoot, double mode, bool bRecurse) override;
+  std::shared_ptr<Promise<void>> syncTreeDownloadAsync(const std::string& remoteRoot, const std::string& localRoot, double mode, bool bRecurse) override;
+  void syncTreeUpload(const std::string& localBaseDir, const std::string& remoteBaseDir, double mode, bool bRecurse) override;
+  std::shared_ptr<Promise<void>> syncTreeUploadAsync(const std::string& localBaseDir, const std::string& remoteBaseDir, double mode, bool bRecurse) override;
+  void uploadBinaryEncoded(const std::string& remotePath, const std::string& encodedData, const std::string& encoding) override;
+  std::shared_ptr<Promise<void>> uploadBinaryEncodedAsync(const std::string& remotePath, const std::string& encodedData, const std::string& encoding) override;
+  void uploadFile(const std::string& localPath, const std::string& remotePath) override;
+  std::shared_ptr<Promise<void>> uploadFileAsync(const std::string& localPath, const std::string& remotePath) override;
+  void uploadString(const std::string& remotePath, const std::string& textData, const std::string& charset) override;
+  std::shared_ptr<Promise<void>> uploadStringAsync(const std::string& remotePath, const std::string& textData, const std::string& charset) override;
+  void useSsh(const std::shared_ptr<HybridSshSpec>& sshConnection) override;
+  void downloadBd(const std::string& remotePath, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  std::shared_ptr<Promise<void>> downloadBdAsync(const std::string& remotePath, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void uploadBd(const std::string& remotePath, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  std::shared_ptr<Promise<void>> uploadBdAsync(const std::string& remotePath, const std::shared_ptr<HybridBinDataSpec>& bd) 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();
+  std::string downloadBinaryEncoded_impl(const std::string& remotePath, const std::string& encoding);
+  void downloadFile_impl(const std::string& remotePath, const std::string& localPath);
+  std::string downloadString_impl(const std::string& remotePath, const std::string& charset);
+  void syncTreeDownload_impl(const std::string& remoteRoot, const std::string& localRoot, double mode, bool bRecurse);
+  void syncTreeUpload_impl(const std::string& localBaseDir, const std::string& remoteBaseDir, double mode, bool bRecurse);
+  void uploadBinaryEncoded_impl(const std::string& remotePath, const std::string& encodedData, const std::string& encoding);
+  void uploadFile_impl(const std::string& localPath, const std::string& remotePath);
+  void uploadString_impl(const std::string& remotePath, const std::string& textData, const std::string& charset);
+  void useSsh_impl(const std::shared_ptr<HybridSshSpec>& sshConnection);
+  void downloadBd_impl(const std::string& remotePath, const std::shared_ptr<HybridBinDataSpec>& bd);
+  void uploadBd_impl(const std::string& remotePath, const std::shared_ptr<HybridBinDataSpec>& bd);
+};
+
+} // namespace margelo::nitro::chilkat