@chilkat/react-native 11.6.1

package/cpp/HybridTar.cpp

@@ -0,0 +1,547 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridTar.hpp"
+#include "HybridBinData.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+#include <CkTarProgress.h>
+
+namespace margelo::nitro::chilkat {
+
+HybridTar::HybridTar()
+    : HybridObject(HybridTarSpec::TAG), ChilkatObject<CkTar>("Tar", CkTar::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridTar::HybridTar(CkTar* owned)
+    : HybridObject(HybridTarSpec::TAG), ChilkatObject<CkTar>("Tar", owned) {
+  init();
+}
+
+void HybridTar::init() {
+  this->installProgress<ProgressAdapter<CkTarProgress>>();
+}
+
+void HybridTar::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridTar::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridTar::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridTar::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridTar::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridTar::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridTar::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridTar::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridTar::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridTar::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridTar::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridTar::getCaptureXmlListing() {
+  this->beginCall();
+  return this->ck().get_CaptureXmlListing();
+}
+void HybridTar::setCaptureXmlListing(bool value) {
+  this->beginCall();
+  this->ck().put_CaptureXmlListing(value);
+}
+std::string HybridTar::getCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Charset(_s);
+  return rt::stdString(_s);
+}
+void HybridTar::setCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "charset");
+  this->ck().put_Charset(value.c_str());
+}
+double HybridTar::getDirMode() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_DirMode());
+}
+void HybridTar::setDirMode(double value) {
+  this->beginCall();
+  this->ck().put_DirMode(rt::toInt(value, "dirMode"));
+}
+std::string HybridTar::getDirPrefix() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DirPrefix(_s);
+  return rt::stdString(_s);
+}
+void HybridTar::setDirPrefix(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "dirPrefix");
+  this->ck().put_DirPrefix(value.c_str());
+}
+double HybridTar::getFileMode() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_FileMode());
+}
+void HybridTar::setFileMode(double value) {
+  this->beginCall();
+  this->ck().put_FileMode(rt::toInt(value, "fileMode"));
+}
+double HybridTar::getGroupId() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_GroupId());
+}
+void HybridTar::setGroupId(double value) {
+  this->beginCall();
+  this->ck().put_GroupId(rt::toInt(value, "groupId"));
+}
+std::string HybridTar::getGroupName() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_GroupName(_s);
+  return rt::stdString(_s);
+}
+void HybridTar::setGroupName(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "groupName");
+  this->ck().put_GroupName(value.c_str());
+}
+double HybridTar::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridTar::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+bool HybridTar::getMatchCaseSensitive() {
+  this->beginCall();
+  return this->ck().get_MatchCaseSensitive();
+}
+void HybridTar::setMatchCaseSensitive(bool value) {
+  this->beginCall();
+  this->ck().put_MatchCaseSensitive(value);
+}
+std::string HybridTar::getMustMatch() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_MustMatch(_s);
+  return rt::stdString(_s);
+}
+void HybridTar::setMustMatch(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "mustMatch");
+  this->ck().put_MustMatch(value.c_str());
+}
+std::string HybridTar::getMustNotMatch() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_MustNotMatch(_s);
+  return rt::stdString(_s);
+}
+void HybridTar::setMustNotMatch(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "mustNotMatch");
+  this->ck().put_MustNotMatch(value.c_str());
+}
+bool HybridTar::getNoAbsolutePaths() {
+  this->beginCall();
+  return this->ck().get_NoAbsolutePaths();
+}
+void HybridTar::setNoAbsolutePaths(bool value) {
+  this->beginCall();
+  this->ck().put_NoAbsolutePaths(value);
+}
+double HybridTar::getNumDirRoots() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumDirRoots());
+}
+double HybridTar::getPercentDoneScale() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_PercentDoneScale());
+}
+void HybridTar::setPercentDoneScale(double value) {
+  this->beginCall();
+  this->ck().put_PercentDoneScale(rt::toInt(value, "percentDoneScale"));
+}
+double HybridTar::getScriptFileMode() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ScriptFileMode());
+}
+void HybridTar::setScriptFileMode(double value) {
+  this->beginCall();
+  this->ck().put_ScriptFileMode(rt::toInt(value, "scriptFileMode"));
+}
+bool HybridTar::getSuppressOutput() {
+  this->beginCall();
+  return this->ck().get_SuppressOutput();
+}
+void HybridTar::setSuppressOutput(bool value) {
+  this->beginCall();
+  this->ck().put_SuppressOutput(value);
+}
+bool HybridTar::getUntarCaseSensitive() {
+  this->beginCall();
+  return this->ck().get_UntarCaseSensitive();
+}
+void HybridTar::setUntarCaseSensitive(bool value) {
+  this->beginCall();
+  this->ck().put_UntarCaseSensitive(value);
+}
+bool HybridTar::getUntarDebugLog() {
+  this->beginCall();
+  return this->ck().get_UntarDebugLog();
+}
+void HybridTar::setUntarDebugLog(bool value) {
+  this->beginCall();
+  this->ck().put_UntarDebugLog(value);
+}
+bool HybridTar::getUntarDiscardPaths() {
+  this->beginCall();
+  return this->ck().get_UntarDiscardPaths();
+}
+void HybridTar::setUntarDiscardPaths(bool value) {
+  this->beginCall();
+  this->ck().put_UntarDiscardPaths(value);
+}
+std::string HybridTar::getUntarFromDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UntarFromDir(_s);
+  return rt::stdString(_s);
+}
+void HybridTar::setUntarFromDir(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "untarFromDir");
+  this->ck().put_UntarFromDir(value.c_str());
+}
+double HybridTar::getUntarMaxCount() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_UntarMaxCount());
+}
+void HybridTar::setUntarMaxCount(double value) {
+  this->beginCall();
+  this->ck().put_UntarMaxCount(rt::toInt(value, "untarMaxCount"));
+}
+double HybridTar::getUserId() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_UserId());
+}
+void HybridTar::setUserId(double value) {
+  this->beginCall();
+  this->ck().put_UserId(rt::toInt(value, "userId"));
+}
+std::string HybridTar::getUserName() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UserName(_s);
+  return rt::stdString(_s);
+}
+void HybridTar::setUserName(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "userName");
+  this->ck().put_UserName(value.c_str());
+}
+std::string HybridTar::getWriteFormat() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_WriteFormat(_s);
+  return rt::stdString(_s);
+}
+void HybridTar::setWriteFormat(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "writeFormat");
+  this->ck().put_WriteFormat(value.c_str());
+}
+std::string HybridTar::getXmlListing() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_XmlListing(_s);
+  return rt::stdString(_s);
+}
+void HybridTar::setXmlListing(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "xmlListing");
+  this->ck().put_XmlListing(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridTar::addDirRoot(const std::string& dirPath) {
+  this->beginCall();
+  addDirRoot_impl(dirPath);
+}
+void HybridTar::addDirRoot_impl(const std::string& dirPath) {
+  rt::checkNoNul(dirPath, "dirPath");
+  if (!this->ck().AddDirRoot(dirPath.c_str())) throw this->fail("addDirRoot");
+}
+
+void HybridTar::addFile(const std::string& path) {
+  this->beginCall();
+  addFile_impl(path);
+}
+void HybridTar::addFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().AddFile(path.c_str())) throw this->fail("addFile");
+}
+
+std::string HybridTar::getDirRoot(double index) {
+  this->beginCall();
+  return getDirRoot_impl(index);
+}
+std::string HybridTar::getDirRoot_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetDirRoot(rt::toInt(index, "index"), _out)) throw this->fail("getDirRoot");
+  return rt::stdString(_out);
+}
+
+std::string HybridTar::listXml(const std::string& tarPath) {
+  this->beginCall();
+  return listXml_impl(tarPath);
+}
+std::string HybridTar::listXml_impl(const std::string& tarPath) {
+  rt::checkNoNul(tarPath, "tarPath");
+  CkString _out;
+  if (!this->ck().ListXml(tarPath.c_str(), _out)) throw this->fail("listXml");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridTar::listXmlAsync(const std::string& tarPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridTar>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Tar.listXmlAsync", std::move(_parts), [_self, tarPath]() {
+    return _self->listXml_impl(tarPath);
+  });
+}
+
+double HybridTar::untar(const std::string& tarPath) {
+  this->beginCall();
+  return untar_impl(tarPath);
+}
+double HybridTar::untar_impl(const std::string& tarPath) {
+  rt::checkNoNul(tarPath, "tarPath");
+  return static_cast<double>(this->ck().Untar(tarPath.c_str()));
+}
+std::shared_ptr<Promise<double>> HybridTar::untarAsync(const std::string& tarPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridTar>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Tar.untarAsync", std::move(_parts), [_self, tarPath]() {
+    return _self->untar_impl(tarPath);
+  });
+}
+
+void HybridTar::untarBz2(const std::string& tarPath) {
+  this->beginCall();
+  untarBz2_impl(tarPath);
+}
+void HybridTar::untarBz2_impl(const std::string& tarPath) {
+  rt::checkNoNul(tarPath, "tarPath");
+  if (!this->ck().UntarBz2(tarPath.c_str())) throw this->fail("untarBz2");
+}
+std::shared_ptr<Promise<void>> HybridTar::untarBz2Async(const std::string& tarPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridTar>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Tar.untarBz2Async", std::move(_parts), [_self, tarPath]() {
+    _self->untarBz2_impl(tarPath);
+  });
+}
+
+void HybridTar::untarGz(const std::string& tarPath) {
+  this->beginCall();
+  untarGz_impl(tarPath);
+}
+void HybridTar::untarGz_impl(const std::string& tarPath) {
+  rt::checkNoNul(tarPath, "tarPath");
+  if (!this->ck().UntarGz(tarPath.c_str())) throw this->fail("untarGz");
+}
+std::shared_ptr<Promise<void>> HybridTar::untarGzAsync(const std::string& tarPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridTar>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Tar.untarGzAsync", std::move(_parts), [_self, tarPath]() {
+    _self->untarGz_impl(tarPath);
+  });
+}
+
+void HybridTar::untarZ(const std::string& tarPath) {
+  this->beginCall();
+  untarZ_impl(tarPath);
+}
+void HybridTar::untarZ_impl(const std::string& tarPath) {
+  rt::checkNoNul(tarPath, "tarPath");
+  if (!this->ck().UntarZ(tarPath.c_str())) throw this->fail("untarZ");
+}
+std::shared_ptr<Promise<void>> HybridTar::untarZAsync(const std::string& tarPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridTar>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Tar.untarZAsync", std::move(_parts), [_self, tarPath]() {
+    _self->untarZ_impl(tarPath);
+  });
+}
+
+bool HybridTar::verifyTar(const std::string& tarPath) {
+  this->beginCall();
+  return verifyTar_impl(tarPath);
+}
+bool HybridTar::verifyTar_impl(const std::string& tarPath) {
+  rt::checkNoNul(tarPath, "tarPath");
+  return this->ck().VerifyTar(tarPath.c_str());
+}
+std::shared_ptr<Promise<bool>> HybridTar::verifyTarAsync(const std::string& tarPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridTar>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<bool>("Tar.verifyTarAsync", std::move(_parts), [_self, tarPath]() {
+    return _self->verifyTar_impl(tarPath);
+  });
+}
+
+void HybridTar::writeTar(const std::string& tarPath) {
+  this->beginCall();
+  writeTar_impl(tarPath);
+}
+void HybridTar::writeTar_impl(const std::string& tarPath) {
+  rt::checkNoNul(tarPath, "tarPath");
+  if (!this->ck().WriteTar(tarPath.c_str())) throw this->fail("writeTar");
+}
+std::shared_ptr<Promise<void>> HybridTar::writeTarAsync(const std::string& tarPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridTar>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Tar.writeTarAsync", std::move(_parts), [_self, tarPath]() {
+    _self->writeTar_impl(tarPath);
+  });
+}
+
+void HybridTar::writeTarBz2(const std::string& bz2Path) {
+  this->beginCall();
+  writeTarBz2_impl(bz2Path);
+}
+void HybridTar::writeTarBz2_impl(const std::string& bz2Path) {
+  rt::checkNoNul(bz2Path, "bz2Path");
+  if (!this->ck().WriteTarBz2(bz2Path.c_str())) throw this->fail("writeTarBz2");
+}
+std::shared_ptr<Promise<void>> HybridTar::writeTarBz2Async(const std::string& bz2Path) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridTar>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Tar.writeTarBz2Async", std::move(_parts), [_self, bz2Path]() {
+    _self->writeTarBz2_impl(bz2Path);
+  });
+}
+
+void HybridTar::writeTarGz(const std::string& gzPath) {
+  this->beginCall();
+  writeTarGz_impl(gzPath);
+}
+void HybridTar::writeTarGz_impl(const std::string& gzPath) {
+  rt::checkNoNul(gzPath, "gzPath");
+  if (!this->ck().WriteTarGz(gzPath.c_str())) throw this->fail("writeTarGz");
+}
+std::shared_ptr<Promise<void>> HybridTar::writeTarGzAsync(const std::string& gzPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridTar>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Tar.writeTarGzAsync", std::move(_parts), [_self, gzPath]() {
+    _self->writeTarGz_impl(gzPath);
+  });
+}
+
+void HybridTar::addDirRoot2(const std::string& rootPrefix, const std::string& rootPath) {
+  this->beginCall();
+  addDirRoot2_impl(rootPrefix, rootPath);
+}
+void HybridTar::addDirRoot2_impl(const std::string& rootPrefix, const std::string& rootPath) {
+  rt::checkNoNul(rootPrefix, "rootPrefix");
+  rt::checkNoNul(rootPath, "rootPath");
+  if (!this->ck().AddDirRoot2(rootPrefix.c_str(), rootPath.c_str())) throw this->fail("addDirRoot2");
+}
+
+void HybridTar::createDeb(const std::string& controlPath, const std::string& dataPath, const std::string& debPath) {
+  this->beginCall();
+  createDeb_impl(controlPath, dataPath, debPath);
+}
+void HybridTar::createDeb_impl(const std::string& controlPath, const std::string& dataPath, const std::string& debPath) {
+  rt::checkNoNul(controlPath, "controlPath");
+  rt::checkNoNul(dataPath, "dataPath");
+  rt::checkNoNul(debPath, "debPath");
+  if (!this->ck().CreateDeb(controlPath.c_str(), dataPath.c_str(), debPath.c_str())) throw this->fail("createDeb");
+}
+
+void HybridTar::addFile2(const std::string& filePath, const std::string& pathWithinTar) {
+  this->beginCall();
+  addFile2_impl(filePath, pathWithinTar);
+}
+void HybridTar::addFile2_impl(const std::string& filePath, const std::string& pathWithinTar) {
+  rt::checkNoNul(filePath, "filePath");
+  rt::checkNoNul(pathWithinTar, "pathWithinTar");
+  if (!this->ck().AddFile2(filePath.c_str(), pathWithinTar.c_str())) throw this->fail("addFile2");
+}
+
+void HybridTar::untarFirstMatchingToBd(const std::string& tarPath, const std::string& matchPattern, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  untarFirstMatchingToBd_impl(tarPath, matchPattern, bd);
+}
+void HybridTar::untarFirstMatchingToBd_impl(const std::string& tarPath, const std::string& matchPattern, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(tarPath, "tarPath");
+  rt::checkNoNul(matchPattern, "matchPattern");
+  if (!this->ck().UntarFirstMatchingToBd(tarPath.c_str(), matchPattern.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("untarFirstMatchingToBd");
+}
+
+void HybridTar::clearDirRootsAndFiles() {
+  this->beginCall();
+  clearDirRootsAndFiles_impl();
+}
+void HybridTar::clearDirRootsAndFiles_impl() {
+  if (!this->ck().ClearDirRootsAndFiles()) throw this->fail("clearDirRootsAndFiles");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridTar::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridTar::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridTar::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridTar::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridTar::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridTar.hpp

@@ -0,0 +1,134 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Tar: the Nitro HybridObject over Chilkat's CkTar (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridTarSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkTar.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridTar final : public HybridTarSpec, public ChilkatObject<CkTar> {
+public:
+  HybridTar();                                  // `new Tar()` from JS
+  explicit HybridTar(CkTar* 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 getCaptureXmlListing() override;
+  void setCaptureXmlListing(bool value) override;
+  std::string getCharset() override;
+  void setCharset(const std::string& value) override;
+  double getDirMode() override;
+  void setDirMode(double value) override;
+  std::string getDirPrefix() override;
+  void setDirPrefix(const std::string& value) override;
+  double getFileMode() override;
+  void setFileMode(double value) override;
+  double getGroupId() override;
+  void setGroupId(double value) override;
+  std::string getGroupName() override;
+  void setGroupName(const std::string& value) override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+  bool getMatchCaseSensitive() override;
+  void setMatchCaseSensitive(bool value) override;
+  std::string getMustMatch() override;
+  void setMustMatch(const std::string& value) override;
+  std::string getMustNotMatch() override;
+  void setMustNotMatch(const std::string& value) override;
+  bool getNoAbsolutePaths() override;
+  void setNoAbsolutePaths(bool value) override;
+  double getNumDirRoots() override;
+  double getPercentDoneScale() override;
+  void setPercentDoneScale(double value) override;
+  double getScriptFileMode() override;
+  void setScriptFileMode(double value) override;
+  bool getSuppressOutput() override;
+  void setSuppressOutput(bool value) override;
+  bool getUntarCaseSensitive() override;
+  void setUntarCaseSensitive(bool value) override;
+  bool getUntarDebugLog() override;
+  void setUntarDebugLog(bool value) override;
+  bool getUntarDiscardPaths() override;
+  void setUntarDiscardPaths(bool value) override;
+  std::string getUntarFromDir() override;
+  void setUntarFromDir(const std::string& value) override;
+  double getUntarMaxCount() override;
+  void setUntarMaxCount(double value) override;
+  double getUserId() override;
+  void setUserId(double value) override;
+  std::string getUserName() override;
+  void setUserName(const std::string& value) override;
+  std::string getWriteFormat() override;
+  void setWriteFormat(const std::string& value) override;
+  std::string getXmlListing() override;
+  void setXmlListing(const std::string& value) override;
+
+  // ---- Methods ----
+  void addDirRoot(const std::string& dirPath) override;
+  void addFile(const std::string& path) override;
+  std::string getDirRoot(double index) override;
+  std::string listXml(const std::string& tarPath) override;
+  std::shared_ptr<Promise<std::string>> listXmlAsync(const std::string& tarPath) override;
+  double untar(const std::string& tarPath) override;
+  std::shared_ptr<Promise<double>> untarAsync(const std::string& tarPath) override;
+  void untarBz2(const std::string& tarPath) override;
+  std::shared_ptr<Promise<void>> untarBz2Async(const std::string& tarPath) override;
+  void untarGz(const std::string& tarPath) override;
+  std::shared_ptr<Promise<void>> untarGzAsync(const std::string& tarPath) override;
+  void untarZ(const std::string& tarPath) override;
+  std::shared_ptr<Promise<void>> untarZAsync(const std::string& tarPath) override;
+  bool verifyTar(const std::string& tarPath) override;
+  std::shared_ptr<Promise<bool>> verifyTarAsync(const std::string& tarPath) override;
+  void writeTar(const std::string& tarPath) override;
+  std::shared_ptr<Promise<void>> writeTarAsync(const std::string& tarPath) override;
+  void writeTarBz2(const std::string& bz2Path) override;
+  std::shared_ptr<Promise<void>> writeTarBz2Async(const std::string& bz2Path) override;
+  void writeTarGz(const std::string& gzPath) override;
+  std::shared_ptr<Promise<void>> writeTarGzAsync(const std::string& gzPath) override;
+  void addDirRoot2(const std::string& rootPrefix, const std::string& rootPath) override;
+  void createDeb(const std::string& controlPath, const std::string& dataPath, const std::string& debPath) override;
+  void addFile2(const std::string& filePath, const std::string& pathWithinTar) override;
+  void untarFirstMatchingToBd(const std::string& tarPath, const std::string& matchPattern, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void clearDirRootsAndFiles() 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 addDirRoot_impl(const std::string& dirPath);
+  void addFile_impl(const std::string& path);
+  std::string getDirRoot_impl(double index);
+  std::string listXml_impl(const std::string& tarPath);
+  double untar_impl(const std::string& tarPath);
+  void untarBz2_impl(const std::string& tarPath);
+  void untarGz_impl(const std::string& tarPath);
+  void untarZ_impl(const std::string& tarPath);
+  bool verifyTar_impl(const std::string& tarPath);
+  void writeTar_impl(const std::string& tarPath);
+  void writeTarBz2_impl(const std::string& bz2Path);
+  void writeTarGz_impl(const std::string& gzPath);
+  void addDirRoot2_impl(const std::string& rootPrefix, const std::string& rootPath);
+  void createDeb_impl(const std::string& controlPath, const std::string& dataPath, const std::string& debPath);
+  void addFile2_impl(const std::string& filePath, const std::string& pathWithinTar);
+  void untarFirstMatchingToBd_impl(const std::string& tarPath, const std::string& matchPattern, const std::shared_ptr<HybridBinDataSpec>& bd);
+  void clearDirRootsAndFiles_impl();
+};
+
+} // namespace margelo::nitro::chilkat