@chilkat/react-native 11.6.1

package/cpp/HybridGzip.cpp

@@ -0,0 +1,440 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridGzip.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCkDateTime.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridGzip::HybridGzip()
+    : HybridObject(HybridGzipSpec::TAG), ChilkatObject<CkGzip>("Gzip", CkGzip::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridGzip::HybridGzip(CkGzip* owned)
+    : HybridObject(HybridGzipSpec::TAG), ChilkatObject<CkGzip>("Gzip", owned) {
+  init();
+}
+
+void HybridGzip::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridGzip::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridGzip::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridGzip::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridGzip::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridGzip::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridGzip::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridGzip::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridGzip::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridGzip::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridGzip::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridGzip::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridGzip::getComment() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Comment(_s);
+  return rt::stdString(_s);
+}
+void HybridGzip::setComment(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "comment");
+  this->ck().put_Comment(value.c_str());
+}
+double HybridGzip::getCompressionLevel() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_CompressionLevel());
+}
+void HybridGzip::setCompressionLevel(double value) {
+  this->beginCall();
+  this->ck().put_CompressionLevel(rt::toInt(value, "compressionLevel"));
+}
+std::string HybridGzip::getFilename() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Filename(_s);
+  return rt::stdString(_s);
+}
+void HybridGzip::setFilename(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "filename");
+  this->ck().put_Filename(value.c_str());
+}
+double HybridGzip::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridGzip::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+std::string HybridGzip::getLastModStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastModStr(_s);
+  return rt::stdString(_s);
+}
+void HybridGzip::setLastModStr(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "lastModStr");
+  this->ck().put_LastModStr(value.c_str());
+}
+bool HybridGzip::getUseCurrentDate() {
+  this->beginCall();
+  return this->ck().get_UseCurrentDate();
+}
+void HybridGzip::setUseCurrentDate(bool value) {
+  this->beginCall();
+  this->ck().put_UseCurrentDate(value);
+}
+bool HybridGzip::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridGzip::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+
+// ---- Methods ----
+
+void HybridGzip::compressFile(const std::string& srcPath, const std::string& destPath) {
+  this->beginCall();
+  compressFile_impl(srcPath, destPath);
+}
+void HybridGzip::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>> HybridGzip::compressFileAsync(const std::string& srcPath, const std::string& destPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridGzip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Gzip.compressFileAsync", std::move(_parts), [_self, srcPath, destPath]() {
+    _self->compressFile_impl(srcPath, destPath);
+  });
+}
+
+void HybridGzip::compressFile2(const std::string& srcPath, const std::string& embeddedFilename, const std::string& destPath) {
+  this->beginCall();
+  compressFile2_impl(srcPath, embeddedFilename, destPath);
+}
+void HybridGzip::compressFile2_impl(const std::string& srcPath, const std::string& embeddedFilename, const std::string& destPath) {
+  rt::checkNoNul(srcPath, "srcPath");
+  rt::checkNoNul(embeddedFilename, "embeddedFilename");
+  rt::checkNoNul(destPath, "destPath");
+  if (!this->ck().CompressFile2(srcPath.c_str(), embeddedFilename.c_str(), destPath.c_str())) throw this->fail("compressFile2");
+}
+std::shared_ptr<Promise<void>> HybridGzip::compressFile2Async(const std::string& srcPath, const std::string& embeddedFilename, const std::string& destPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridGzip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Gzip.compressFile2Async", std::move(_parts), [_self, srcPath, embeddedFilename, destPath]() {
+    _self->compressFile2_impl(srcPath, embeddedFilename, destPath);
+  });
+}
+
+std::string HybridGzip::compressStringENC(const std::string& inStr, const std::string& charset, const std::string& encoding) {
+  this->beginCall();
+  return compressStringENC_impl(inStr, charset, encoding);
+}
+std::string HybridGzip::compressStringENC_impl(const std::string& inStr, const std::string& charset, const std::string& encoding) {
+  rt::checkNoNul(inStr, "inStr");
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().CompressStringENC(inStr.c_str(), charset.c_str(), encoding.c_str(), _out)) throw this->fail("compressStringENC");
+  return rt::stdString(_out);
+}
+
+void HybridGzip::compressStringToFile(const std::string& inStr, const std::string& destCharset, const std::string& destPath) {
+  this->beginCall();
+  compressStringToFile_impl(inStr, destCharset, destPath);
+}
+void HybridGzip::compressStringToFile_impl(const std::string& inStr, const std::string& destCharset, const std::string& destPath) {
+  rt::checkNoNul(inStr, "inStr");
+  rt::checkNoNul(destCharset, "destCharset");
+  rt::checkNoNul(destPath, "destPath");
+  if (!this->ck().CompressStringToFile(inStr.c_str(), destCharset.c_str(), destPath.c_str())) throw this->fail("compressStringToFile");
+}
+std::shared_ptr<Promise<void>> HybridGzip::compressStringToFileAsync(const std::string& inStr, const std::string& destCharset, const std::string& destPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridGzip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Gzip.compressStringToFileAsync", std::move(_parts), [_self, inStr, destCharset, destPath]() {
+    _self->compressStringToFile_impl(inStr, destCharset, destPath);
+  });
+}
+
+void HybridGzip::setDt(const std::shared_ptr<HybridCkDateTimeSpec>& dt) {
+  this->beginCall();
+  setDt_impl(dt);
+}
+void HybridGzip::setDt_impl(const std::shared_ptr<HybridCkDateTimeSpec>& dt) {
+  if (!this->ck().SetDt(rt::implOf<HybridCkDateTime>(dt, "dt").ck())) throw this->fail("setDt");
+}
+
+void HybridGzip::unTarGz(const std::string& gzPath, const std::string& destDir, bool bNoAbsolute) {
+  this->beginCall();
+  unTarGz_impl(gzPath, destDir, bNoAbsolute);
+}
+void HybridGzip::unTarGz_impl(const std::string& gzPath, const std::string& destDir, bool bNoAbsolute) {
+  rt::checkNoNul(gzPath, "gzPath");
+  rt::checkNoNul(destDir, "destDir");
+  if (!this->ck().UnTarGz(gzPath.c_str(), destDir.c_str(), bNoAbsolute)) throw this->fail("unTarGz");
+}
+std::shared_ptr<Promise<void>> HybridGzip::unTarGzAsync(const std::string& gzPath, const std::string& destDir, bool bNoAbsolute) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridGzip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Gzip.unTarGzAsync", std::move(_parts), [_self, gzPath, destDir, bNoAbsolute]() {
+    _self->unTarGz_impl(gzPath, destDir, bNoAbsolute);
+  });
+}
+
+void HybridGzip::uncompressFile(const std::string& srcPath, const std::string& destPath) {
+  this->beginCall();
+  uncompressFile_impl(srcPath, destPath);
+}
+void HybridGzip::uncompressFile_impl(const std::string& srcPath, const std::string& destPath) {
+  rt::checkNoNul(srcPath, "srcPath");
+  rt::checkNoNul(destPath, "destPath");
+  if (!this->ck().UncompressFile(srcPath.c_str(), destPath.c_str())) throw this->fail("uncompressFile");
+}
+std::shared_ptr<Promise<void>> HybridGzip::uncompressFileAsync(const std::string& srcPath, const std::string& destPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridGzip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Gzip.uncompressFileAsync", std::move(_parts), [_self, srcPath, destPath]() {
+    _self->uncompressFile_impl(srcPath, destPath);
+  });
+}
+
+std::string HybridGzip::uncompressFileToString(const std::string& srcPath, const std::string& charset) {
+  this->beginCall();
+  return uncompressFileToString_impl(srcPath, charset);
+}
+std::string HybridGzip::uncompressFileToString_impl(const std::string& srcPath, const std::string& charset) {
+  rt::checkNoNul(srcPath, "srcPath");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().UncompressFileToString(srcPath.c_str(), charset.c_str(), _out)) throw this->fail("uncompressFileToString");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridGzip::uncompressFileToStringAsync(const std::string& srcPath, const std::string& charset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridGzip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Gzip.uncompressFileToStringAsync", std::move(_parts), [_self, srcPath, charset]() {
+    return _self->uncompressFileToString_impl(srcPath, charset);
+  });
+}
+
+std::string HybridGzip::uncompressStringENC(const std::string& inStr, const std::string& charset, const std::string& encoding) {
+  this->beginCall();
+  return uncompressStringENC_impl(inStr, charset, encoding);
+}
+std::string HybridGzip::uncompressStringENC_impl(const std::string& inStr, const std::string& charset, const std::string& encoding) {
+  rt::checkNoNul(inStr, "inStr");
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().UncompressStringENC(inStr.c_str(), charset.c_str(), encoding.c_str(), _out)) throw this->fail("uncompressStringENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridGzip::xfdlToXml(const std::string& xfldData) {
+  this->beginCall();
+  return xfdlToXml_impl(xfldData);
+}
+std::string HybridGzip::xfdlToXml_impl(const std::string& xfldData) {
+  rt::checkNoNul(xfldData, "xfldData");
+  CkString _out;
+  if (!this->ck().XfdlToXml(xfldData.c_str(), _out)) throw this->fail("xfdlToXml");
+  return rt::stdString(_out);
+}
+
+void HybridGzip::uncompressBd(const std::shared_ptr<HybridBinDataSpec>& binDat) {
+  this->beginCall();
+  uncompressBd_impl(binDat);
+}
+void HybridGzip::uncompressBd_impl(const std::shared_ptr<HybridBinDataSpec>& binDat) {
+  if (!this->ck().UncompressBd(rt::implOf<HybridBinData>(binDat, "binDat").ck())) throw this->fail("uncompressBd");
+}
+std::shared_ptr<Promise<void>> HybridGzip::uncompressBdAsync(const std::shared_ptr<HybridBinDataSpec>& binDat) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridGzip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binDat);
+  return rt::runAsync<void>("Gzip.uncompressBdAsync", std::move(_parts), [_self, binDat]() {
+    _self->uncompressBd_impl(binDat);
+  });
+}
+
+void HybridGzip::compressBd(const std::shared_ptr<HybridBinDataSpec>& binDat) {
+  this->beginCall();
+  compressBd_impl(binDat);
+}
+void HybridGzip::compressBd_impl(const std::shared_ptr<HybridBinDataSpec>& binDat) {
+  if (!this->ck().CompressBd(rt::implOf<HybridBinData>(binDat, "binDat").ck())) throw this->fail("compressBd");
+}
+std::shared_ptr<Promise<void>> HybridGzip::compressBdAsync(const std::shared_ptr<HybridBinDataSpec>& binDat) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridGzip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binDat);
+  return rt::runAsync<void>("Gzip.compressBdAsync", std::move(_parts), [_self, binDat]() {
+    _self->compressBd_impl(binDat);
+  });
+}
+
+void HybridGzip::setExtraData(const std::string& encodedData, const std::string& encoding) {
+  this->beginCall();
+  setExtraData_impl(encodedData, encoding);
+}
+void HybridGzip::setExtraData_impl(const std::string& encodedData, const std::string& encoding) {
+  rt::checkNoNul(encodedData, "encodedData");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().SetExtraData(encodedData.c_str(), encoding.c_str())) throw this->fail("setExtraData");
+}
+
+void HybridGzip::compressFileBd(const std::string& filePath, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  compressFileBd_impl(filePath, bd);
+}
+void HybridGzip::compressFileBd_impl(const std::string& filePath, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(filePath, "filePath");
+  if (!this->ck().CompressFileBd(filePath.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("compressFileBd");
+}
+std::shared_ptr<Promise<void>> HybridGzip::compressFileBdAsync(const std::string& filePath, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridGzip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("Gzip.compressFileBdAsync", std::move(_parts), [_self, filePath, bd]() {
+    _self->compressFileBd_impl(filePath, bd);
+  });
+}
+
+void HybridGzip::compressSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  compressSb_impl(sb, charset, bd);
+}
+void HybridGzip::compressSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().CompressSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck(), charset.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("compressSb");
+}
+std::shared_ptr<Promise<void>> HybridGzip::compressSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridGzip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  _parts.push_back(bd);
+  return rt::runAsync<void>("Gzip.compressSbAsync", std::move(_parts), [_self, sb, charset, bd]() {
+    _self->compressSb_impl(sb, charset, bd);
+  });
+}
+
+bool HybridGzip::isGzip(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  return isGzip_impl(bd);
+}
+bool HybridGzip::isGzip_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  return this->ck().IsGzip(rt::implOf<HybridBinData>(bd, "bd").ck());
+}
+
+void HybridGzip::uncompressBdToFile(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filePath) {
+  this->beginCall();
+  uncompressBdToFile_impl(bd, filePath);
+}
+void HybridGzip::uncompressBdToFile_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filePath) {
+  rt::checkNoNul(filePath, "filePath");
+  if (!this->ck().UncompressBdToFile(rt::implOf<HybridBinData>(bd, "bd").ck(), filePath.c_str())) throw this->fail("uncompressBdToFile");
+}
+std::shared_ptr<Promise<void>> HybridGzip::uncompressBdToFileAsync(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filePath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridGzip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<void>("Gzip.uncompressBdToFileAsync", std::move(_parts), [_self, bd, filePath]() {
+    _self->uncompressBdToFile_impl(bd, filePath);
+  });
+}
+
+void HybridGzip::getGzipInfo(const std::string& filePath, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getGzipInfo_impl(filePath, json);
+}
+void HybridGzip::getGzipInfo_impl(const std::string& filePath, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  rt::checkNoNul(filePath, "filePath");
+  if (!this->ck().GetGzipInfo(filePath.c_str(), rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("getGzipInfo");
+}
+
+void HybridGzip::getGzipInfoBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getGzipInfoBd_impl(bd, json);
+}
+void HybridGzip::getGzipInfoBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().GetGzipInfoBd(rt::implOf<HybridBinData>(bd, "bd").ck(), rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("getGzipInfoBd");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridGzip::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridGzip::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridGzip::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridGzip::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridGzip::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridGzip.hpp

@@ -0,0 +1,105 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Gzip: the Nitro HybridObject over Chilkat's CkGzip (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridGzipSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkGzip.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridGzip final : public HybridGzipSpec, public ChilkatObject<CkGzip> {
+public:
+  HybridGzip();                                  // `new Gzip()` from JS
+  explicit HybridGzip(CkGzip* 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;
+  double getCompressionLevel() override;
+  void setCompressionLevel(double value) override;
+  std::string getFilename() override;
+  void setFilename(const std::string& value) override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+  std::string getLastModStr() override;
+  void setLastModStr(const std::string& value) override;
+  bool getUseCurrentDate() override;
+  void setUseCurrentDate(bool value) override;
+  bool getAbortCurrent() override;
+  void setAbortCurrent(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 compressFile2(const std::string& srcPath, const std::string& embeddedFilename, const std::string& destPath) override;
+  std::shared_ptr<Promise<void>> compressFile2Async(const std::string& srcPath, const std::string& embeddedFilename, const std::string& destPath) override;
+  std::string compressStringENC(const std::string& inStr, const std::string& charset, const std::string& encoding) override;
+  void compressStringToFile(const std::string& inStr, const std::string& destCharset, const std::string& destPath) override;
+  std::shared_ptr<Promise<void>> compressStringToFileAsync(const std::string& inStr, const std::string& destCharset, const std::string& destPath) override;
+  void setDt(const std::shared_ptr<HybridCkDateTimeSpec>& dt) override;
+  void unTarGz(const std::string& gzPath, const std::string& destDir, bool bNoAbsolute) override;
+  std::shared_ptr<Promise<void>> unTarGzAsync(const std::string& gzPath, const std::string& destDir, bool bNoAbsolute) override;
+  void uncompressFile(const std::string& srcPath, const std::string& destPath) override;
+  std::shared_ptr<Promise<void>> uncompressFileAsync(const std::string& srcPath, const std::string& destPath) override;
+  std::string uncompressFileToString(const std::string& srcPath, const std::string& charset) override;
+  std::shared_ptr<Promise<std::string>> uncompressFileToStringAsync(const std::string& srcPath, const std::string& charset) override;
+  std::string uncompressStringENC(const std::string& inStr, const std::string& charset, const std::string& encoding) override;
+  std::string xfdlToXml(const std::string& xfldData) override;
+  void uncompressBd(const std::shared_ptr<HybridBinDataSpec>& binDat) override;
+  std::shared_ptr<Promise<void>> uncompressBdAsync(const std::shared_ptr<HybridBinDataSpec>& binDat) override;
+  void compressBd(const std::shared_ptr<HybridBinDataSpec>& binDat) override;
+  std::shared_ptr<Promise<void>> compressBdAsync(const std::shared_ptr<HybridBinDataSpec>& binDat) override;
+  void setExtraData(const std::string& encodedData, const std::string& encoding) override;
+  void compressFileBd(const std::string& filePath, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  std::shared_ptr<Promise<void>> compressFileBdAsync(const std::string& filePath, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void compressSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  std::shared_ptr<Promise<void>> compressSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  bool isGzip(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void uncompressBdToFile(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filePath) override;
+  std::shared_ptr<Promise<void>> uncompressBdToFileAsync(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filePath) override;
+  void getGzipInfo(const std::string& filePath, const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void getGzipInfoBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+
+  // ---- Events (ReactNativeGen_DESIGN.md §6) ----
+  std::optional<std::function<void(double)>> getOnPercentDone() override;
+  void setOnPercentDone(const std::optional<std::function<void(double)>>& cb) override;
+  std::optional<std::function<void(const std::string&, const std::string&)>> getOnProgressInfo() override;
+  void setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) override;
+  void abort() override;
+
+private:
+  void init();
+  void compressFile_impl(const std::string& srcPath, const std::string& destPath);
+  void compressFile2_impl(const std::string& srcPath, const std::string& embeddedFilename, const std::string& destPath);
+  std::string compressStringENC_impl(const std::string& inStr, const std::string& charset, const std::string& encoding);
+  void compressStringToFile_impl(const std::string& inStr, const std::string& destCharset, const std::string& destPath);
+  void setDt_impl(const std::shared_ptr<HybridCkDateTimeSpec>& dt);
+  void unTarGz_impl(const std::string& gzPath, const std::string& destDir, bool bNoAbsolute);
+  void uncompressFile_impl(const std::string& srcPath, const std::string& destPath);
+  std::string uncompressFileToString_impl(const std::string& srcPath, const std::string& charset);
+  std::string uncompressStringENC_impl(const std::string& inStr, const std::string& charset, const std::string& encoding);
+  std::string xfdlToXml_impl(const std::string& xfldData);
+  void uncompressBd_impl(const std::shared_ptr<HybridBinDataSpec>& binDat);
+  void compressBd_impl(const std::shared_ptr<HybridBinDataSpec>& binDat);
+  void setExtraData_impl(const std::string& encodedData, const std::string& encoding);
+  void compressFileBd_impl(const std::string& filePath, const std::shared_ptr<HybridBinDataSpec>& bd);
+  void compressSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset, const std::shared_ptr<HybridBinDataSpec>& bd);
+  bool isGzip_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  void uncompressBdToFile_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filePath);
+  void getGzipInfo_impl(const std::string& filePath, const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void getGzipInfoBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::shared_ptr<HybridJsonObjectSpec>& json);
+};
+
+} // namespace margelo::nitro::chilkat