@chilkat/react-native 11.6.1

package/cpp/HybridCodeSign.hpp

@@ -0,0 +1,55 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// CodeSign: the Nitro HybridObject over Chilkat's CkCodeSign (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridCodeSignSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkCodeSign.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridCodeSign final : public HybridCodeSignSpec, public ChilkatObject<CkCodeSign> {
+public:
+  HybridCodeSign();                                  // `new CodeSign()` from JS
+  explicit HybridCodeSign(CkCodeSign* 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 getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+
+  // ---- Methods ----
+  void verifySignature(const std::string& path, const std::shared_ptr<HybridJsonObjectSpec>& sigInfo) override;
+  void removeSignature(const std::string& path) override;
+  void addSignature(const std::string& path, const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridJsonObjectSpec>& options) override;
+  std::shared_ptr<Promise<void>> addSignatureAsync(const std::string& path, const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridJsonObjectSpec>& options) override;
+  void getSignerCert(const std::shared_ptr<HybridCertSpec>& cert) 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 verifySignature_impl(const std::string& path, const std::shared_ptr<HybridJsonObjectSpec>& sigInfo);
+  void removeSignature_impl(const std::string& path);
+  void addSignature_impl(const std::string& path, const std::shared_ptr<HybridCertSpec>& cert, const std::shared_ptr<HybridJsonObjectSpec>& options);
+  void getSignerCert_impl(const std::shared_ptr<HybridCertSpec>& cert);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridCompression.cpp

@@ -0,0 +1,422 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridCompression.hpp"
+#include "HybridBinData.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridStream.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridCompression::HybridCompression()
+    : HybridObject(HybridCompressionSpec::TAG), ChilkatObject<CkCompression>("Compression", CkCompression::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridCompression::HybridCompression(CkCompression* owned)
+    : HybridObject(HybridCompressionSpec::TAG), ChilkatObject<CkCompression>("Compression", owned) {
+  init();
+}
+
+void HybridCompression::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridCompression::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridCompression::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCompression::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCompression::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCompression::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCompression::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridCompression::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridCompression::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridCompression::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridCompression::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridCompression::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridCompression::getAlgorithm() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Algorithm(_s);
+  return rt::stdString(_s);
+}
+void HybridCompression::setAlgorithm(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "algorithm");
+  this->ck().put_Algorithm(value.c_str());
+}
+std::string HybridCompression::getCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Charset(_s);
+  return rt::stdString(_s);
+}
+void HybridCompression::setCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "charset");
+  this->ck().put_Charset(value.c_str());
+}
+std::string HybridCompression::getEncodingMode() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_EncodingMode(_s);
+  return rt::stdString(_s);
+}
+void HybridCompression::setEncodingMode(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "encodingMode");
+  this->ck().put_EncodingMode(value.c_str());
+}
+double HybridCompression::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridCompression::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+double HybridCompression::getDeflateLevel() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_DeflateLevel());
+}
+void HybridCompression::setDeflateLevel(double value) {
+  this->beginCall();
+  this->ck().put_DeflateLevel(rt::toInt(value, "deflateLevel"));
+}
+std::string HybridCompression::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridCompression::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+bool HybridCompression::getFirstChunk() {
+  this->beginCall();
+  return this->ck().get_FirstChunk();
+}
+void HybridCompression::setFirstChunk(bool value) {
+  this->beginCall();
+  this->ck().put_FirstChunk(value);
+}
+bool HybridCompression::getLastChunk() {
+  this->beginCall();
+  return this->ck().get_LastChunk();
+}
+void HybridCompression::setLastChunk(bool value) {
+  this->beginCall();
+  this->ck().put_LastChunk(value);
+}
+
+// ---- Methods ----
+
+void HybridCompression::compressFile(const std::string& srcPath, const std::string& destPath) {
+  this->beginCall();
+  compressFile_impl(srcPath, destPath);
+}
+void HybridCompression::compressFile_impl(const std::string& srcPath, const std::string& destPath) {
+  rt::checkNoNul(srcPath, "srcPath");
+  rt::checkNoNul(destPath, "destPath");
+  if (!this->ck().CompressFile(srcPath.c_str(), destPath.c_str())) throw this->fail("compressFile");
+}
+std::shared_ptr<Promise<void>> HybridCompression::compressFileAsync(const std::string& srcPath, const std::string& destPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCompression>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Compression.compressFileAsync", std::move(_parts), [_self, srcPath, destPath]() {
+    _self->compressFile_impl(srcPath, destPath);
+  });
+}
+
+void HybridCompression::compressStream(const std::shared_ptr<HybridStreamSpec>& strm) {
+  this->beginCall();
+  compressStream_impl(strm);
+}
+void HybridCompression::compressStream_impl(const std::shared_ptr<HybridStreamSpec>& strm) {
+  if (!this->ck().CompressStream(rt::implOf<HybridStream>(strm, "strm").ck())) throw this->fail("compressStream");
+}
+std::shared_ptr<Promise<void>> HybridCompression::compressStreamAsync(const std::shared_ptr<HybridStreamSpec>& strm) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCompression>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(strm);
+  return rt::runAsync<void>("Compression.compressStreamAsync", std::move(_parts), [_self, strm]() {
+    _self->compressStream_impl(strm);
+  });
+}
+
+std::string HybridCompression::compressStringENC(const std::string& str) {
+  this->beginCall();
+  return compressStringENC_impl(str);
+}
+std::string HybridCompression::compressStringENC_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  CkString _out;
+  if (!this->ck().CompressStringENC(str.c_str(), _out)) throw this->fail("compressStringENC");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridCompression::compressStringENCAsync(const std::string& str) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCompression>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Compression.compressStringENCAsync", std::move(_parts), [_self, str]() {
+    return _self->compressStringENC_impl(str);
+  });
+}
+
+void HybridCompression::decompressFile(const std::string& srcPath, const std::string& destPath) {
+  this->beginCall();
+  decompressFile_impl(srcPath, destPath);
+}
+void HybridCompression::decompressFile_impl(const std::string& srcPath, const std::string& destPath) {
+  rt::checkNoNul(srcPath, "srcPath");
+  rt::checkNoNul(destPath, "destPath");
+  if (!this->ck().DecompressFile(srcPath.c_str(), destPath.c_str())) throw this->fail("decompressFile");
+}
+std::shared_ptr<Promise<void>> HybridCompression::decompressFileAsync(const std::string& srcPath, const std::string& destPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCompression>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Compression.decompressFileAsync", std::move(_parts), [_self, srcPath, destPath]() {
+    _self->decompressFile_impl(srcPath, destPath);
+  });
+}
+
+void HybridCompression::decompressStream(const std::shared_ptr<HybridStreamSpec>& strm) {
+  this->beginCall();
+  decompressStream_impl(strm);
+}
+void HybridCompression::decompressStream_impl(const std::shared_ptr<HybridStreamSpec>& strm) {
+  if (!this->ck().DecompressStream(rt::implOf<HybridStream>(strm, "strm").ck())) throw this->fail("decompressStream");
+}
+std::shared_ptr<Promise<void>> HybridCompression::decompressStreamAsync(const std::shared_ptr<HybridStreamSpec>& strm) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCompression>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(strm);
+  return rt::runAsync<void>("Compression.decompressStreamAsync", std::move(_parts), [_self, strm]() {
+    _self->decompressStream_impl(strm);
+  });
+}
+
+std::string HybridCompression::decompressStringENC(const std::string& encodedCompressedData) {
+  this->beginCall();
+  return decompressStringENC_impl(encodedCompressedData);
+}
+std::string HybridCompression::decompressStringENC_impl(const std::string& encodedCompressedData) {
+  rt::checkNoNul(encodedCompressedData, "encodedCompressedData");
+  CkString _out;
+  if (!this->ck().DecompressStringENC(encodedCompressedData.c_str(), _out)) throw this->fail("decompressStringENC");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridCompression::decompressStringENCAsync(const std::string& encodedCompressedData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCompression>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Compression.decompressStringENCAsync", std::move(_parts), [_self, encodedCompressedData]() {
+    return _self->decompressStringENC_impl(encodedCompressedData);
+  });
+}
+
+void HybridCompression::compressBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  compressBd_impl(bd);
+}
+void HybridCompression::compressBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().CompressBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("compressBd");
+}
+std::shared_ptr<Promise<void>> HybridCompression::compressBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCompression>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("Compression.compressBdAsync", std::move(_parts), [_self, bd]() {
+    _self->compressBd_impl(bd);
+  });
+}
+
+void HybridCompression::decompressBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  decompressBd_impl(bd);
+}
+void HybridCompression::decompressBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().DecompressBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("decompressBd");
+}
+std::shared_ptr<Promise<void>> HybridCompression::decompressBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCompression>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("Compression.decompressBdAsync", std::move(_parts), [_self, bd]() {
+    _self->decompressBd_impl(bd);
+  });
+}
+
+void HybridCompression::compressSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  compressSb_impl(sb, binData);
+}
+void HybridCompression::compressSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().CompressSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck(), rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("compressSb");
+}
+std::shared_ptr<Promise<void>> HybridCompression::compressSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCompression>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  _parts.push_back(binData);
+  return rt::runAsync<void>("Compression.compressSbAsync", std::move(_parts), [_self, sb, binData]() {
+    _self->compressSb_impl(sb, binData);
+  });
+}
+
+void HybridCompression::decompressSb(const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  decompressSb_impl(binData, sb);
+}
+void HybridCompression::decompressSb_impl(const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().DecompressSb(rt::implOf<HybridBinData>(binData, "binData").ck(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("decompressSb");
+}
+std::shared_ptr<Promise<void>> HybridCompression::decompressSbAsync(const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCompression>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  _parts.push_back(sb);
+  return rt::runAsync<void>("Compression.decompressSbAsync", std::move(_parts), [_self, binData, sb]() {
+    _self->decompressSb_impl(binData, sb);
+  });
+}
+
+void HybridCompression::compressEncryptFile(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath) {
+  this->beginCall();
+  compressEncryptFile_impl(cryptParams, srcPath, destPath);
+}
+void HybridCompression::compressEncryptFile_impl(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath) {
+  rt::checkNoNul(srcPath, "srcPath");
+  rt::checkNoNul(destPath, "destPath");
+  if (!this->ck().CompressEncryptFile(rt::implOf<HybridJsonObject>(cryptParams, "cryptParams").ck(), srcPath.c_str(), destPath.c_str())) throw this->fail("compressEncryptFile");
+}
+std::shared_ptr<Promise<void>> HybridCompression::compressEncryptFileAsync(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCompression>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(cryptParams);
+  return rt::runAsync<void>("Compression.compressEncryptFileAsync", std::move(_parts), [_self, cryptParams, srcPath, destPath]() {
+    _self->compressEncryptFile_impl(cryptParams, srcPath, destPath);
+  });
+}
+
+void HybridCompression::decryptDecompressFile(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath) {
+  this->beginCall();
+  decryptDecompressFile_impl(cryptParams, srcPath, destPath);
+}
+void HybridCompression::decryptDecompressFile_impl(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath) {
+  rt::checkNoNul(srcPath, "srcPath");
+  rt::checkNoNul(destPath, "destPath");
+  if (!this->ck().DecryptDecompressFile(rt::implOf<HybridJsonObject>(cryptParams, "cryptParams").ck(), srcPath.c_str(), destPath.c_str())) throw this->fail("decryptDecompressFile");
+}
+std::shared_ptr<Promise<void>> HybridCompression::decryptDecompressFileAsync(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCompression>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(cryptParams);
+  return rt::runAsync<void>("Compression.decryptDecompressFileAsync", std::move(_parts), [_self, cryptParams, srcPath, destPath]() {
+    _self->decryptDecompressFile_impl(cryptParams, srcPath, destPath);
+  });
+}
+
+void HybridCompression::compressBd2(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) {
+  this->beginCall();
+  compressBd2_impl(bdIn, bdOut);
+}
+void HybridCompression::compressBd2_impl(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) {
+  if (!this->ck().CompressBd2(rt::implOf<HybridBinData>(bdIn, "bdIn").ck(), rt::implOf<HybridBinData>(bdOut, "bdOut").ck())) throw this->fail("compressBd2");
+}
+std::shared_ptr<Promise<void>> HybridCompression::compressBd2Async(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCompression>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bdIn);
+  _parts.push_back(bdOut);
+  return rt::runAsync<void>("Compression.compressBd2Async", std::move(_parts), [_self, bdIn, bdOut]() {
+    _self->compressBd2_impl(bdIn, bdOut);
+  });
+}
+
+void HybridCompression::decompressBd2(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) {
+  this->beginCall();
+  decompressBd2_impl(bdIn, bdOut);
+}
+void HybridCompression::decompressBd2_impl(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) {
+  if (!this->ck().DecompressBd2(rt::implOf<HybridBinData>(bdIn, "bdIn").ck(), rt::implOf<HybridBinData>(bdOut, "bdOut").ck())) throw this->fail("decompressBd2");
+}
+std::shared_ptr<Promise<void>> HybridCompression::decompressBd2Async(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridCompression>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bdIn);
+  _parts.push_back(bdOut);
+  return rt::runAsync<void>("Compression.decompressBd2Async", std::move(_parts), [_self, bdIn, bdOut]() {
+    _self->decompressBd2_impl(bdIn, bdOut);
+  });
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridCompression::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridCompression::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridCompression::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridCompression::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridCompression::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridCompression.hpp

@@ -0,0 +1,100 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Compression: the Nitro HybridObject over Chilkat's CkCompression (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridCompressionSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkCompression.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridCompression final : public HybridCompressionSpec, public ChilkatObject<CkCompression> {
+public:
+  HybridCompression();                                  // `new Compression()` from JS
+  explicit HybridCompression(CkCompression* 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 getAlgorithm() override;
+  void setAlgorithm(const std::string& value) override;
+  std::string getCharset() override;
+  void setCharset(const std::string& value) override;
+  std::string getEncodingMode() override;
+  void setEncodingMode(const std::string& value) override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+  double getDeflateLevel() override;
+  void setDeflateLevel(double value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+  bool getFirstChunk() override;
+  void setFirstChunk(bool value) override;
+  bool getLastChunk() override;
+  void setLastChunk(bool value) override;
+
+  // ---- Methods ----
+  void compressFile(const std::string& srcPath, const std::string& destPath) override;
+  std::shared_ptr<Promise<void>> compressFileAsync(const std::string& srcPath, const std::string& destPath) override;
+  void compressStream(const std::shared_ptr<HybridStreamSpec>& strm) override;
+  std::shared_ptr<Promise<void>> compressStreamAsync(const std::shared_ptr<HybridStreamSpec>& strm) override;
+  std::string compressStringENC(const std::string& str) override;
+  std::shared_ptr<Promise<std::string>> compressStringENCAsync(const std::string& str) override;
+  void decompressFile(const std::string& srcPath, const std::string& destPath) override;
+  std::shared_ptr<Promise<void>> decompressFileAsync(const std::string& srcPath, const std::string& destPath) override;
+  void decompressStream(const std::shared_ptr<HybridStreamSpec>& strm) override;
+  std::shared_ptr<Promise<void>> decompressStreamAsync(const std::shared_ptr<HybridStreamSpec>& strm) override;
+  std::string decompressStringENC(const std::string& encodedCompressedData) override;
+  std::shared_ptr<Promise<std::string>> decompressStringENCAsync(const std::string& encodedCompressedData) override;
+  void compressBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  std::shared_ptr<Promise<void>> compressBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void decompressBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  std::shared_ptr<Promise<void>> decompressBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void compressSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  std::shared_ptr<Promise<void>> compressSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  void decompressSb(const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  std::shared_ptr<Promise<void>> decompressSbAsync(const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void compressEncryptFile(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath) override;
+  std::shared_ptr<Promise<void>> compressEncryptFileAsync(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath) override;
+  void decryptDecompressFile(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath) override;
+  std::shared_ptr<Promise<void>> decryptDecompressFileAsync(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath) override;
+  void compressBd2(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) override;
+  std::shared_ptr<Promise<void>> compressBd2Async(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) override;
+  void decompressBd2(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) override;
+  std::shared_ptr<Promise<void>> decompressBd2Async(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut) 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 compressFile_impl(const std::string& srcPath, const std::string& destPath);
+  void compressStream_impl(const std::shared_ptr<HybridStreamSpec>& strm);
+  std::string compressStringENC_impl(const std::string& str);
+  void decompressFile_impl(const std::string& srcPath, const std::string& destPath);
+  void decompressStream_impl(const std::shared_ptr<HybridStreamSpec>& strm);
+  std::string decompressStringENC_impl(const std::string& encodedCompressedData);
+  void compressBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  void decompressBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  void compressSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::shared_ptr<HybridBinDataSpec>& binData);
+  void decompressSb_impl(const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void compressEncryptFile_impl(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath);
+  void decryptDecompressFile_impl(const std::shared_ptr<HybridJsonObjectSpec>& cryptParams, const std::string& srcPath, const std::string& destPath);
+  void compressBd2_impl(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut);
+  void decompressBd2_impl(const std::shared_ptr<HybridBinDataSpec>& bdIn, const std::shared_ptr<HybridBinDataSpec>& bdOut);
+};
+
+} // namespace margelo::nitro::chilkat