@chilkat/react-native 11.6.1

package/cpp/HybridZip.cpp

@@ -0,0 +1,1000 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridZip.hpp"
+#include "HybridBinData.hpp"
+#include "HybridStringArray.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridZipEntry.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+#include <CkZipProgress.h>
+
+namespace margelo::nitro::chilkat {
+
+HybridZip::HybridZip()
+    : HybridObject(HybridZipSpec::TAG), ChilkatObject<CkZip>("Zip", CkZip::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridZip::HybridZip(CkZip* owned)
+    : HybridObject(HybridZipSpec::TAG), ChilkatObject<CkZip>("Zip", owned) {
+  init();
+}
+
+void HybridZip::init() {
+  this->installProgress<ProgressAdapter<CkZipProgress>>();
+}
+
+void HybridZip::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridZip::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridZip::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridZip::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridZip::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridZip::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridZip::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridZip::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridZip::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridZip::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridZip::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridZip::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+std::string HybridZip::getAppendFromDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AppendFromDir(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setAppendFromDir(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "appendFromDir");
+  this->ck().put_AppendFromDir(value.c_str());
+}
+std::string HybridZip::getAutoRun() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AutoRun(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setAutoRun(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "autoRun");
+  this->ck().put_AutoRun(value.c_str());
+}
+std::string HybridZip::getAutoRunParams() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AutoRunParams(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setAutoRunParams(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "autoRunParams");
+  this->ck().put_AutoRunParams(value.c_str());
+}
+bool HybridZip::getAutoTemp() {
+  this->beginCall();
+  return this->ck().get_AutoTemp();
+}
+void HybridZip::setAutoTemp(bool value) {
+  this->beginCall();
+  this->ck().put_AutoTemp(value);
+}
+bool HybridZip::getCaseSensitive() {
+  this->beginCall();
+  return this->ck().get_CaseSensitive();
+}
+void HybridZip::setCaseSensitive(bool value) {
+  this->beginCall();
+  this->ck().put_CaseSensitive(value);
+}
+bool HybridZip::getClearArchiveAttribute() {
+  this->beginCall();
+  return this->ck().get_ClearArchiveAttribute();
+}
+void HybridZip::setClearArchiveAttribute(bool value) {
+  this->beginCall();
+  this->ck().put_ClearArchiveAttribute(value);
+}
+bool HybridZip::getClearReadOnlyAttr() {
+  this->beginCall();
+  return this->ck().get_ClearReadOnlyAttr();
+}
+void HybridZip::setClearReadOnlyAttr(bool value) {
+  this->beginCall();
+  this->ck().put_ClearReadOnlyAttr(value);
+}
+std::string HybridZip::getComment() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Comment(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setComment(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "comment");
+  this->ck().put_Comment(value.c_str());
+}
+std::string HybridZip::getDecryptPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DecryptPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setDecryptPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "decryptPassword");
+  this->ck().put_DecryptPassword(value.c_str());
+}
+bool HybridZip::getDiscardPaths() {
+  this->beginCall();
+  return this->ck().get_DiscardPaths();
+}
+void HybridZip::setDiscardPaths(bool value) {
+  this->beginCall();
+  this->ck().put_DiscardPaths(value);
+}
+double HybridZip::getEncryptKeyLength() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_EncryptKeyLength());
+}
+void HybridZip::setEncryptKeyLength(double value) {
+  this->beginCall();
+  this->ck().put_EncryptKeyLength(rt::toInt(value, "encryptKeyLength"));
+}
+std::string HybridZip::getEncryptPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_EncryptPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setEncryptPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "encryptPassword");
+  this->ck().put_EncryptPassword(value.c_str());
+}
+double HybridZip::getEncryption() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Encryption());
+}
+void HybridZip::setEncryption(double value) {
+  this->beginCall();
+  this->ck().put_Encryption(rt::toInt(value, "encryption"));
+}
+std::string HybridZip::getExeDefaultDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ExeDefaultDir(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setExeDefaultDir(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "exeDefaultDir");
+  this->ck().put_ExeDefaultDir(value.c_str());
+}
+bool HybridZip::getExeFinishNotifier() {
+  this->beginCall();
+  return this->ck().get_ExeFinishNotifier();
+}
+void HybridZip::setExeFinishNotifier(bool value) {
+  this->beginCall();
+  this->ck().put_ExeFinishNotifier(value);
+}
+std::string HybridZip::getExeIconFile() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ExeIconFile(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setExeIconFile(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "exeIconFile");
+  this->ck().put_ExeIconFile(value.c_str());
+}
+bool HybridZip::getExeNoInterface() {
+  this->beginCall();
+  return this->ck().get_ExeNoInterface();
+}
+void HybridZip::setExeNoInterface(bool value) {
+  this->beginCall();
+  this->ck().put_ExeNoInterface(value);
+}
+bool HybridZip::getExeSilentProgress() {
+  this->beginCall();
+  return this->ck().get_ExeSilentProgress();
+}
+void HybridZip::setExeSilentProgress(bool value) {
+  this->beginCall();
+  this->ck().put_ExeSilentProgress(value);
+}
+std::string HybridZip::getExeTitle() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ExeTitle(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setExeTitle(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "exeTitle");
+  this->ck().put_ExeTitle(value.c_str());
+}
+std::string HybridZip::getExeUnzipCaption() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ExeUnzipCaption(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setExeUnzipCaption(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "exeUnzipCaption");
+  this->ck().put_ExeUnzipCaption(value.c_str());
+}
+std::string HybridZip::getExeUnzipDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ExeUnzipDir(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setExeUnzipDir(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "exeUnzipDir");
+  this->ck().put_ExeUnzipDir(value.c_str());
+}
+bool HybridZip::getExeWaitForSetup() {
+  this->beginCall();
+  return this->ck().get_ExeWaitForSetup();
+}
+void HybridZip::setExeWaitForSetup(bool value) {
+  this->beginCall();
+  this->ck().put_ExeWaitForSetup(value);
+}
+std::string HybridZip::getExeXmlConfig() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ExeXmlConfig(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setExeXmlConfig(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "exeXmlConfig");
+  this->ck().put_ExeXmlConfig(value.c_str());
+}
+double HybridZip::getFileCount() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_FileCount());
+}
+std::string HybridZip::getFileName() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FileName(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setFileName(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "fileName");
+  this->ck().put_FileName(value.c_str());
+}
+bool HybridZip::getHasZipFormatErrors() {
+  this->beginCall();
+  return this->ck().get_HasZipFormatErrors();
+}
+double HybridZip::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridZip::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+bool HybridZip::getIgnoreAccessDenied() {
+  this->beginCall();
+  return this->ck().get_IgnoreAccessDenied();
+}
+void HybridZip::setIgnoreAccessDenied(bool value) {
+  this->beginCall();
+  this->ck().put_IgnoreAccessDenied(value);
+}
+double HybridZip::getNumEntries() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumEntries());
+}
+double HybridZip::getOemCodePage() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_OemCodePage());
+}
+void HybridZip::setOemCodePage(double value) {
+  this->beginCall();
+  this->ck().put_OemCodePage(rt::toInt(value, "oemCodePage"));
+}
+bool HybridZip::getOverwriteExisting() {
+  this->beginCall();
+  return this->ck().get_OverwriteExisting();
+}
+void HybridZip::setOverwriteExisting(bool value) {
+  this->beginCall();
+  this->ck().put_OverwriteExisting(value);
+}
+bool HybridZip::getPasswordProtect() {
+  this->beginCall();
+  return this->ck().get_PasswordProtect();
+}
+void HybridZip::setPasswordProtect(bool value) {
+  this->beginCall();
+  this->ck().put_PasswordProtect(value);
+}
+std::string HybridZip::getPathPrefix() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_PathPrefix(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setPathPrefix(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "pathPrefix");
+  this->ck().put_PathPrefix(value.c_str());
+}
+double HybridZip::getPercentDoneScale() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_PercentDoneScale());
+}
+void HybridZip::setPercentDoneScale(double value) {
+  this->beginCall();
+  this->ck().put_PercentDoneScale(rt::toInt(value, "percentDoneScale"));
+}
+std::string HybridZip::getTempDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TempDir(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setTempDir(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "tempDir");
+  this->ck().put_TempDir(value.c_str());
+}
+bool HybridZip::getZipx() {
+  this->beginCall();
+  return this->ck().get_Zipx();
+}
+void HybridZip::setZipx(bool value) {
+  this->beginCall();
+  this->ck().put_Zipx(value);
+}
+std::string HybridZip::getZipxDefaultAlg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ZipxDefaultAlg(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setZipxDefaultAlg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "zipxDefaultAlg");
+  this->ck().put_ZipxDefaultAlg(value.c_str());
+}
+std::string HybridZip::getPwdProtCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_PwdProtCharset(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setPwdProtCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "pwdProtCharset");
+  this->ck().put_PwdProtCharset(value.c_str());
+}
+std::string HybridZip::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+double HybridZip::getMaxUncompressSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_MaxUncompressSize());
+}
+void HybridZip::setMaxUncompressSize(double value) {
+  this->beginCall();
+  this->ck().put_MaxUncompressSize(rt::toULong(value, "maxUncompressSize"));
+}
+std::string HybridZip::getMinDate() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_MinDate(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setMinDate(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "minDate");
+  this->ck().put_MinDate(value.c_str());
+}
+std::string HybridZip::getMaxDate() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_MaxDate(_s);
+  return rt::stdString(_s);
+}
+void HybridZip::setMaxDate(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "maxDate");
+  this->ck().put_MaxDate(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridZip::addNoCompressExtension(const std::string& fileExtension) {
+  this->beginCall();
+  addNoCompressExtension_impl(fileExtension);
+}
+void HybridZip::addNoCompressExtension_impl(const std::string& fileExtension) {
+  rt::checkNoNul(fileExtension, "fileExtension");
+  this->ck().AddNoCompressExtension(fileExtension.c_str());
+}
+
+void HybridZip::appendFiles(const std::string& filePattern, bool recurse) {
+  this->beginCall();
+  appendFiles_impl(filePattern, recurse);
+}
+void HybridZip::appendFiles_impl(const std::string& filePattern, bool recurse) {
+  rt::checkNoNul(filePattern, "filePattern");
+  if (!this->ck().AppendFiles(filePattern.c_str(), recurse)) throw this->fail("appendFiles");
+}
+std::shared_ptr<Promise<void>> HybridZip::appendFilesAsync(const std::string& filePattern, bool recurse) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Zip.appendFilesAsync", std::move(_parts), [_self, filePattern, recurse]() {
+    _self->appendFiles_impl(filePattern, recurse);
+  });
+}
+
+void HybridZip::appendFilesEx(const std::string& filePattern, bool recurse, bool saveExtraPath, bool archiveOnly, bool includeHidden, bool includeSystem) {
+  this->beginCall();
+  appendFilesEx_impl(filePattern, recurse, saveExtraPath, archiveOnly, includeHidden, includeSystem);
+}
+void HybridZip::appendFilesEx_impl(const std::string& filePattern, bool recurse, bool saveExtraPath, bool archiveOnly, bool includeHidden, bool includeSystem) {
+  rt::checkNoNul(filePattern, "filePattern");
+  if (!this->ck().AppendFilesEx(filePattern.c_str(), recurse, saveExtraPath, archiveOnly, includeHidden, includeSystem)) throw this->fail("appendFilesEx");
+}
+std::shared_ptr<Promise<void>> HybridZip::appendFilesExAsync(const std::string& filePattern, bool recurse, bool saveExtraPath, bool archiveOnly, bool includeHidden, bool includeSystem) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Zip.appendFilesExAsync", std::move(_parts), [_self, filePattern, recurse, saveExtraPath, archiveOnly, includeHidden, includeSystem]() {
+    _self->appendFilesEx_impl(filePattern, recurse, saveExtraPath, archiveOnly, includeHidden, includeSystem);
+  });
+}
+
+void HybridZip::appendZip(const std::string& zipPath) {
+  this->beginCall();
+  appendZip_impl(zipPath);
+}
+void HybridZip::appendZip_impl(const std::string& zipPath) {
+  rt::checkNoNul(zipPath, "zipPath");
+  if (!this->ck().AppendZip(zipPath.c_str())) throw this->fail("appendZip");
+}
+
+void HybridZip::closeZip() {
+  this->beginCall();
+  closeZip_impl();
+}
+void HybridZip::closeZip_impl() {
+  this->ck().CloseZip();
+}
+
+void HybridZip::deleteEntry(const std::shared_ptr<HybridZipEntrySpec>& entry) {
+  this->beginCall();
+  deleteEntry_impl(entry);
+}
+void HybridZip::deleteEntry_impl(const std::shared_ptr<HybridZipEntrySpec>& entry) {
+  if (!this->ck().DeleteEntry(rt::implOf<HybridZipEntry>(entry, "entry").ck())) throw this->fail("deleteEntry");
+}
+
+void HybridZip::excludeDir(const std::string& dirName) {
+  this->beginCall();
+  excludeDir_impl(dirName);
+}
+void HybridZip::excludeDir_impl(const std::string& dirName) {
+  rt::checkNoNul(dirName, "dirName");
+  this->ck().ExcludeDir(dirName.c_str());
+}
+
+void HybridZip::extractExe(const std::string& exePath, const std::string& dirPath) {
+  this->beginCall();
+  extractExe_impl(exePath, dirPath);
+}
+void HybridZip::extractExe_impl(const std::string& exePath, const std::string& dirPath) {
+  rt::checkNoNul(exePath, "exePath");
+  rt::checkNoNul(dirPath, "dirPath");
+  if (!this->ck().ExtractExe(exePath.c_str(), dirPath.c_str())) throw this->fail("extractExe");
+}
+std::shared_ptr<Promise<void>> HybridZip::extractExeAsync(const std::string& exePath, const std::string& dirPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Zip.extractExeAsync", std::move(_parts), [_self, exePath, dirPath]() {
+    _self->extractExe_impl(exePath, dirPath);
+  });
+}
+
+std::string HybridZip::getDirectoryAsXML() {
+  this->beginCall();
+  return getDirectoryAsXML_impl();
+}
+std::string HybridZip::getDirectoryAsXML_impl() {
+  CkString _out;
+  if (!this->ck().GetDirectoryAsXML(_out)) throw this->fail("getDirectoryAsXML");
+  return rt::stdString(_out);
+}
+
+std::string HybridZip::getExeConfigParam(const std::string& name) {
+  this->beginCall();
+  return getExeConfigParam_impl(name);
+}
+std::string HybridZip::getExeConfigParam_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  CkString _out;
+  if (!this->ck().GetExeConfigParam(name.c_str(), _out)) throw this->fail("getExeConfigParam");
+  return rt::stdString(_out);
+}
+
+bool HybridZip::isNoCompressExtension(const std::string& fileExtension) {
+  this->beginCall();
+  return isNoCompressExtension_impl(fileExtension);
+}
+bool HybridZip::isNoCompressExtension_impl(const std::string& fileExtension) {
+  rt::checkNoNul(fileExtension, "fileExtension");
+  return this->ck().IsNoCompressExtension(fileExtension.c_str());
+}
+
+bool HybridZip::isPasswordProtected(const std::string& zipPath) {
+  this->beginCall();
+  return isPasswordProtected_impl(zipPath);
+}
+bool HybridZip::isPasswordProtected_impl(const std::string& zipPath) {
+  rt::checkNoNul(zipPath, "zipPath");
+  return this->ck().IsPasswordProtected(zipPath.c_str());
+}
+
+void HybridZip::newZip(const std::string& zipPath) {
+  this->beginCall();
+  newZip_impl(zipPath);
+}
+void HybridZip::newZip_impl(const std::string& zipPath) {
+  rt::checkNoNul(zipPath, "zipPath");
+  if (!this->ck().NewZip(zipPath.c_str())) throw this->fail("newZip");
+}
+
+void HybridZip::openEmbedded(const std::string& exeFilename, const std::string& resourceName) {
+  this->beginCall();
+  openEmbedded_impl(exeFilename, resourceName);
+}
+void HybridZip::openEmbedded_impl(const std::string& exeFilename, const std::string& resourceName) {
+  rt::checkNoNul(exeFilename, "exeFilename");
+  rt::checkNoNul(resourceName, "resourceName");
+  if (!this->ck().OpenEmbedded(exeFilename.c_str(), resourceName.c_str())) throw this->fail("openEmbedded");
+}
+
+void HybridZip::openZip(const std::string& zipPath) {
+  this->beginCall();
+  openZip_impl(zipPath);
+}
+void HybridZip::openZip_impl(const std::string& zipPath) {
+  rt::checkNoNul(zipPath, "zipPath");
+  if (!this->ck().OpenZip(zipPath.c_str())) throw this->fail("openZip");
+}
+std::shared_ptr<Promise<void>> HybridZip::openZipAsync(const std::string& zipPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Zip.openZipAsync", std::move(_parts), [_self, zipPath]() {
+    _self->openZip_impl(zipPath);
+  });
+}
+
+void HybridZip::quickAppend(const std::string& zipPath) {
+  this->beginCall();
+  quickAppend_impl(zipPath);
+}
+void HybridZip::quickAppend_impl(const std::string& zipPath) {
+  rt::checkNoNul(zipPath, "zipPath");
+  if (!this->ck().QuickAppend(zipPath.c_str())) throw this->fail("quickAppend");
+}
+std::shared_ptr<Promise<void>> HybridZip::quickAppendAsync(const std::string& zipPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Zip.quickAppendAsync", std::move(_parts), [_self, zipPath]() {
+    _self->quickAppend_impl(zipPath);
+  });
+}
+
+void HybridZip::removeNoCompressExtension(const std::string& fileExtension) {
+  this->beginCall();
+  removeNoCompressExtension_impl(fileExtension);
+}
+void HybridZip::removeNoCompressExtension_impl(const std::string& fileExtension) {
+  rt::checkNoNul(fileExtension, "fileExtension");
+  this->ck().RemoveNoCompressExtension(fileExtension.c_str());
+}
+
+void HybridZip::setCompressionLevel(double level) {
+  this->beginCall();
+  setCompressionLevel_impl(level);
+}
+void HybridZip::setCompressionLevel_impl(double level) {
+  this->ck().SetCompressionLevel(rt::toInt(level, "level"));
+}
+
+void HybridZip::setExclusions(const std::shared_ptr<HybridStringArraySpec>& excludePatterns) {
+  this->beginCall();
+  setExclusions_impl(excludePatterns);
+}
+void HybridZip::setExclusions_impl(const std::shared_ptr<HybridStringArraySpec>& excludePatterns) {
+  this->ck().SetExclusions(rt::implOf<HybridStringArray>(excludePatterns, "excludePatterns").ck());
+}
+
+void HybridZip::setExeConfigParam(const std::string& paramName, const std::string& paramValue) {
+  this->beginCall();
+  setExeConfigParam_impl(paramName, paramValue);
+}
+void HybridZip::setExeConfigParam_impl(const std::string& paramName, const std::string& paramValue) {
+  rt::checkNoNul(paramName, "paramName");
+  rt::checkNoNul(paramValue, "paramValue");
+  this->ck().SetExeConfigParam(paramName.c_str(), paramValue.c_str());
+}
+
+double HybridZip::unzip(const std::string& dirPath) {
+  this->beginCall();
+  return unzip_impl(dirPath);
+}
+double HybridZip::unzip_impl(const std::string& dirPath) {
+  rt::checkNoNul(dirPath, "dirPath");
+  return static_cast<double>(this->ck().Unzip(dirPath.c_str()));
+}
+std::shared_ptr<Promise<double>> HybridZip::unzipAsync(const std::string& dirPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Zip.unzipAsync", std::move(_parts), [_self, dirPath]() {
+    return _self->unzip_impl(dirPath);
+  });
+}
+
+double HybridZip::unzipInto(const std::string& dirPath) {
+  this->beginCall();
+  return unzipInto_impl(dirPath);
+}
+double HybridZip::unzipInto_impl(const std::string& dirPath) {
+  rt::checkNoNul(dirPath, "dirPath");
+  return static_cast<double>(this->ck().UnzipInto(dirPath.c_str()));
+}
+std::shared_ptr<Promise<double>> HybridZip::unzipIntoAsync(const std::string& dirPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Zip.unzipIntoAsync", std::move(_parts), [_self, dirPath]() {
+    return _self->unzipInto_impl(dirPath);
+  });
+}
+
+double HybridZip::unzipMatching(const std::string& dirPath, const std::string& pattern, bool verbose) {
+  this->beginCall();
+  return unzipMatching_impl(dirPath, pattern, verbose);
+}
+double HybridZip::unzipMatching_impl(const std::string& dirPath, const std::string& pattern, bool verbose) {
+  rt::checkNoNul(dirPath, "dirPath");
+  rt::checkNoNul(pattern, "pattern");
+  return static_cast<double>(this->ck().UnzipMatching(dirPath.c_str(), pattern.c_str(), verbose));
+}
+std::shared_ptr<Promise<double>> HybridZip::unzipMatchingAsync(const std::string& dirPath, const std::string& pattern, bool verbose) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Zip.unzipMatchingAsync", std::move(_parts), [_self, dirPath, pattern, verbose]() {
+    return _self->unzipMatching_impl(dirPath, pattern, verbose);
+  });
+}
+
+double HybridZip::unzipMatchingInto(const std::string& dirPath, const std::string& pattern, bool verbose) {
+  this->beginCall();
+  return unzipMatchingInto_impl(dirPath, pattern, verbose);
+}
+double HybridZip::unzipMatchingInto_impl(const std::string& dirPath, const std::string& pattern, bool verbose) {
+  rt::checkNoNul(dirPath, "dirPath");
+  rt::checkNoNul(pattern, "pattern");
+  return static_cast<double>(this->ck().UnzipMatchingInto(dirPath.c_str(), pattern.c_str(), verbose));
+}
+std::shared_ptr<Promise<double>> HybridZip::unzipMatchingIntoAsync(const std::string& dirPath, const std::string& pattern, bool verbose) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Zip.unzipMatchingIntoAsync", std::move(_parts), [_self, dirPath, pattern, verbose]() {
+    return _self->unzipMatchingInto_impl(dirPath, pattern, verbose);
+  });
+}
+
+double HybridZip::unzipNewer(const std::string& dirPath) {
+  this->beginCall();
+  return unzipNewer_impl(dirPath);
+}
+double HybridZip::unzipNewer_impl(const std::string& dirPath) {
+  rt::checkNoNul(dirPath, "dirPath");
+  return static_cast<double>(this->ck().UnzipNewer(dirPath.c_str()));
+}
+std::shared_ptr<Promise<double>> HybridZip::unzipNewerAsync(const std::string& dirPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Zip.unzipNewerAsync", std::move(_parts), [_self, dirPath]() {
+    return _self->unzipNewer_impl(dirPath);
+  });
+}
+
+bool HybridZip::verifyPassword() {
+  this->beginCall();
+  return verifyPassword_impl();
+}
+bool HybridZip::verifyPassword_impl() {
+  return this->ck().VerifyPassword();
+}
+
+void HybridZip::writeExe(const std::string& exeFilename) {
+  this->beginCall();
+  writeExe_impl(exeFilename);
+}
+void HybridZip::writeExe_impl(const std::string& exeFilename) {
+  rt::checkNoNul(exeFilename, "exeFilename");
+  if (!this->ck().WriteExe(exeFilename.c_str())) throw this->fail("writeExe");
+}
+std::shared_ptr<Promise<void>> HybridZip::writeExeAsync(const std::string& exeFilename) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Zip.writeExeAsync", std::move(_parts), [_self, exeFilename]() {
+    _self->writeExe_impl(exeFilename);
+  });
+}
+
+void HybridZip::writeExe2(const std::string& exePath, const std::string& destExePath, bool bAesEncrypt, double keyLength, const std::string& password) {
+  this->beginCall();
+  writeExe2_impl(exePath, destExePath, bAesEncrypt, keyLength, password);
+}
+void HybridZip::writeExe2_impl(const std::string& exePath, const std::string& destExePath, bool bAesEncrypt, double keyLength, const std::string& password) {
+  rt::checkNoNul(exePath, "exePath");
+  rt::checkNoNul(destExePath, "destExePath");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().WriteExe2(exePath.c_str(), destExePath.c_str(), bAesEncrypt, rt::toInt(keyLength, "keyLength"), password.c_str())) throw this->fail("writeExe2");
+}
+std::shared_ptr<Promise<void>> HybridZip::writeExe2Async(const std::string& exePath, const std::string& destExePath, bool bAesEncrypt, double keyLength, const std::string& password) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Zip.writeExe2Async", std::move(_parts), [_self, exePath, destExePath, bAesEncrypt, keyLength, password]() {
+    _self->writeExe2_impl(exePath, destExePath, bAesEncrypt, keyLength, password);
+  });
+}
+
+void HybridZip::writeZip() {
+  this->beginCall();
+  writeZip_impl();
+}
+void HybridZip::writeZip_impl() {
+  if (!this->ck().WriteZip()) throw this->fail("writeZip");
+}
+std::shared_ptr<Promise<void>> HybridZip::writeZipAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Zip.writeZipAsync", std::move(_parts), [_self]() {
+    _self->writeZip_impl();
+  });
+}
+
+void HybridZip::writeZipAndClose() {
+  this->beginCall();
+  writeZipAndClose_impl();
+}
+void HybridZip::writeZipAndClose_impl() {
+  if (!this->ck().WriteZipAndClose()) throw this->fail("writeZipAndClose");
+}
+std::shared_ptr<Promise<void>> HybridZip::writeZipAndCloseAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Zip.writeZipAndCloseAsync", std::move(_parts), [_self]() {
+    _self->writeZipAndClose_impl();
+  });
+}
+
+void HybridZip::writeBd(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  writeBd_impl(binData);
+}
+void HybridZip::writeBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().WriteBd(rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("writeBd");
+}
+std::shared_ptr<Promise<void>> HybridZip::writeBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridZip>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  return rt::runAsync<void>("Zip.writeBdAsync", std::move(_parts), [_self, binData]() {
+    _self->writeBd_impl(binData);
+  });
+}
+
+void HybridZip::openBd(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  openBd_impl(binData);
+}
+void HybridZip::openBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().OpenBd(rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("openBd");
+}
+
+std::string HybridZip::getMaxUncompressedSize() {
+  this->beginCall();
+  return getMaxUncompressedSize_impl();
+}
+std::string HybridZip::getMaxUncompressedSize_impl() {
+  CkString _out;
+  if (!this->ck().GetMaxUncompressedSize(_out)) throw this->fail("getMaxUncompressedSize");
+  return rt::stdString(_out);
+}
+
+void HybridZip::addBd(const std::string& pathInZip, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  addBd_impl(pathInZip, bd);
+}
+void HybridZip::addBd_impl(const std::string& pathInZip, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(pathInZip, "pathInZip");
+  if (!this->ck().AddBd(pathInZip.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("addBd");
+}
+
+void HybridZip::addEncoded(const std::string& pathInZip, const std::string& encoding, const std::string& data) {
+  this->beginCall();
+  addEncoded_impl(pathInZip, encoding, data);
+}
+void HybridZip::addEncoded_impl(const std::string& pathInZip, const std::string& encoding, const std::string& data) {
+  rt::checkNoNul(pathInZip, "pathInZip");
+  rt::checkNoNul(encoding, "encoding");
+  rt::checkNoNul(data, "data");
+  if (!this->ck().AddEncoded(pathInZip.c_str(), encoding.c_str(), data.c_str())) throw this->fail("addEncoded");
+}
+
+void HybridZip::addEmpty(bool isDir, const std::string& pathInZip) {
+  this->beginCall();
+  addEmpty_impl(isDir, pathInZip);
+}
+void HybridZip::addEmpty_impl(bool isDir, const std::string& pathInZip) {
+  rt::checkNoNul(pathInZip, "pathInZip");
+  if (!this->ck().AddEmpty(isDir, pathInZip.c_str())) throw this->fail("addEmpty");
+}
+
+void HybridZip::addString(const std::string& pathInZip, const std::string& content, const std::string& charset) {
+  this->beginCall();
+  addString_impl(pathInZip, content, charset);
+}
+void HybridZip::addString_impl(const std::string& pathInZip, const std::string& content, const std::string& charset) {
+  rt::checkNoNul(pathInZip, "pathInZip");
+  rt::checkNoNul(content, "content");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().AddString(pathInZip.c_str(), content.c_str(), charset.c_str())) throw this->fail("addString");
+}
+
+void HybridZip::addSb(const std::string& pathInZip, const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) {
+  this->beginCall();
+  addSb_impl(pathInZip, sb, charset);
+}
+void HybridZip::addSb_impl(const std::string& pathInZip, const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) {
+  rt::checkNoNul(pathInZip, "pathInZip");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().AddSb(pathInZip.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck(), charset.c_str())) throw this->fail("addSb");
+}
+
+void HybridZip::addFile(const std::string& localPath, bool saveExtraPath) {
+  this->beginCall();
+  addFile_impl(localPath, saveExtraPath);
+}
+void HybridZip::addFile_impl(const std::string& localPath, bool saveExtraPath) {
+  rt::checkNoNul(localPath, "localPath");
+  if (!this->ck().AddFile(localPath.c_str(), saveExtraPath)) throw this->fail("addFile");
+}
+
+void HybridZip::entryAt(double index, const std::shared_ptr<HybridZipEntrySpec>& entry) {
+  this->beginCall();
+  entryAt_impl(index, entry);
+}
+void HybridZip::entryAt_impl(double index, const std::shared_ptr<HybridZipEntrySpec>& entry) {
+  if (!this->ck().EntryAt(rt::toInt(index, "index"), rt::implOf<HybridZipEntry>(entry, "entry").ck())) throw this->fail("entryAt");
+}
+
+void HybridZip::entryMatching(const std::string& pattern, const std::shared_ptr<HybridZipEntrySpec>& entry) {
+  this->beginCall();
+  entryMatching_impl(pattern, entry);
+}
+void HybridZip::entryMatching_impl(const std::string& pattern, const std::shared_ptr<HybridZipEntrySpec>& entry) {
+  rt::checkNoNul(pattern, "pattern");
+  if (!this->ck().EntryMatching(pattern.c_str(), rt::implOf<HybridZipEntry>(entry, "entry").ck())) throw this->fail("entryMatching");
+}
+
+bool HybridZip::entryOf(const std::string& pathInZip, const std::shared_ptr<HybridZipEntrySpec>& entry) {
+  this->beginCall();
+  return entryOf_impl(pathInZip, entry);
+}
+bool HybridZip::entryOf_impl(const std::string& pathInZip, const std::shared_ptr<HybridZipEntrySpec>& entry) {
+  rt::checkNoNul(pathInZip, "pathInZip");
+  return this->ck().EntryOf(pathInZip.c_str(), rt::implOf<HybridZipEntry>(entry, "entry").ck());
+}
+
+void HybridZip::entryById(double id, const std::shared_ptr<HybridZipEntrySpec>& entry) {
+  this->beginCall();
+  entryById_impl(id, entry);
+}
+void HybridZip::entryById_impl(double id, const std::shared_ptr<HybridZipEntrySpec>& entry) {
+  if (!this->ck().EntryById(rt::toInt(id, "id"), rt::implOf<HybridZipEntry>(entry, "entry").ck())) throw this->fail("entryById");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridZip::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridZip::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridZip::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridZip::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridZip::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat