@chilkat/react-native 11.6.1

package/nitrogen/generated/shared/c++/HybridZipEntrySpec.hpp

@@ -0,0 +1,137 @@
+///
+/// HybridZipEntrySpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridCkDateTimeSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCkDateTimeSpec; }
+// Forward declaration of `HybridStreamSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStreamSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridCkDateTimeSpec.hpp"
+#include "HybridStreamSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ZipEntry`
+   * Inherit this class to create instances of `HybridZipEntrySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridZipEntry: public HybridZipEntrySpec {
+   * public:
+   *   HybridZipEntry(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridZipEntrySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridZipEntrySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridZipEntrySpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual std::string getComment() = 0;
+      virtual void setComment(const std::string& comment) = 0;
+      virtual double getCompressedLength() = 0;
+      virtual double getCompressedLength64() = 0;
+      virtual std::string getCompressedLengthStr() = 0;
+      virtual double getCompressionLevel() = 0;
+      virtual void setCompressionLevel(double compressionLevel) = 0;
+      virtual double getCompressionMethod() = 0;
+      virtual void setCompressionMethod(double compressionMethod) = 0;
+      virtual double getCrc() = 0;
+      virtual double getEntryID() = 0;
+      virtual double getEntryType() = 0;
+      virtual std::string getFileDateTimeStr() = 0;
+      virtual void setFileDateTimeStr(const std::string& fileDateTimeStr) = 0;
+      virtual std::string getFileName() = 0;
+      virtual void setFileName(const std::string& fileName) = 0;
+      virtual std::string getFileNameHex() = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual bool getIsDirectory() = 0;
+      virtual bool getTextFlag() = 0;
+      virtual void setTextFlag(bool textFlag) = 0;
+      virtual double getUncompressedLength() = 0;
+      virtual double getUncompressedLength64() = 0;
+      virtual std::string getUncompressedLengthStr() = 0;
+      virtual bool getIsAesEncrypted() = 0;
+      virtual double getEncryptionKeyLen() = 0;
+      virtual std::optional<std::function<void(double /* pctDone */)>> getOnPercentDone() = 0;
+      virtual void setOnPercentDone(const std::optional<std::function<void(double /* pctDone */)>>& onPercentDone) = 0;
+      virtual std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>> getOnProgressInfo() = 0;
+      virtual void setOnProgressInfo(const std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>>& onProgressInfo) = 0;
+
+    public:
+      // Methods
+      virtual void appendString(const std::string& strContent, const std::string& charset) = 0;
+      virtual std::shared_ptr<Promise<void>> appendStringAsync(const std::string& strContent, const std::string& charset) = 0;
+      virtual std::string copyToBase64() = 0;
+      virtual std::string copyToHex() = 0;
+      virtual void extract(const std::string& dirPath) = 0;
+      virtual std::shared_ptr<Promise<void>> extractAsync(const std::string& dirPath) = 0;
+      virtual void extractInto(const std::string& dirPath) = 0;
+      virtual std::shared_ptr<Promise<void>> extractIntoAsync(const std::string& dirPath) = 0;
+      virtual void replaceString(const std::string& strContent, const std::string& charset) = 0;
+      virtual void setDt(const std::shared_ptr<HybridCkDateTimeSpec>& dt) = 0;
+      virtual std::string unzipToString(double lineEndingBehavior, const std::string& srcCharset) = 0;
+      virtual std::shared_ptr<Promise<std::string>> unzipToStringAsync(double lineEndingBehavior, const std::string& srcCharset) = 0;
+      virtual void unzipToStream(const std::shared_ptr<HybridStreamSpec>& toStream) = 0;
+      virtual std::shared_ptr<Promise<void>> unzipToStreamAsync(const std::shared_ptr<HybridStreamSpec>& toStream) = 0;
+      virtual void unzipToBd(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual std::shared_ptr<Promise<void>> unzipToBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual void unzipToSb(double lineEndingBehavior, const std::string& srcCharset, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual std::shared_ptr<Promise<void>> unzipToSbAsync(double lineEndingBehavior, const std::string& srcCharset, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void getNextMatch(const std::string& pattern) = 0;
+      virtual void getNext() = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ZipEntry";
+  };
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridZipSpec.cpp

@@ -0,0 +1,176 @@
+///
+/// HybridZipSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridZipSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridZipSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridZipSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridZipSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridZipSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridZipSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridZipSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridZipSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridZipSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridZipSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridZipSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridZipSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("abortCurrent", &HybridZipSpec::getAbortCurrent);
+      prototype.registerHybridSetter("abortCurrent", &HybridZipSpec::setAbortCurrent);
+      prototype.registerHybridGetter("appendFromDir", &HybridZipSpec::getAppendFromDir);
+      prototype.registerHybridSetter("appendFromDir", &HybridZipSpec::setAppendFromDir);
+      prototype.registerHybridGetter("autoRun", &HybridZipSpec::getAutoRun);
+      prototype.registerHybridSetter("autoRun", &HybridZipSpec::setAutoRun);
+      prototype.registerHybridGetter("autoRunParams", &HybridZipSpec::getAutoRunParams);
+      prototype.registerHybridSetter("autoRunParams", &HybridZipSpec::setAutoRunParams);
+      prototype.registerHybridGetter("autoTemp", &HybridZipSpec::getAutoTemp);
+      prototype.registerHybridSetter("autoTemp", &HybridZipSpec::setAutoTemp);
+      prototype.registerHybridGetter("caseSensitive", &HybridZipSpec::getCaseSensitive);
+      prototype.registerHybridSetter("caseSensitive", &HybridZipSpec::setCaseSensitive);
+      prototype.registerHybridGetter("clearArchiveAttribute", &HybridZipSpec::getClearArchiveAttribute);
+      prototype.registerHybridSetter("clearArchiveAttribute", &HybridZipSpec::setClearArchiveAttribute);
+      prototype.registerHybridGetter("clearReadOnlyAttr", &HybridZipSpec::getClearReadOnlyAttr);
+      prototype.registerHybridSetter("clearReadOnlyAttr", &HybridZipSpec::setClearReadOnlyAttr);
+      prototype.registerHybridGetter("comment", &HybridZipSpec::getComment);
+      prototype.registerHybridSetter("comment", &HybridZipSpec::setComment);
+      prototype.registerHybridGetter("decryptPassword", &HybridZipSpec::getDecryptPassword);
+      prototype.registerHybridSetter("decryptPassword", &HybridZipSpec::setDecryptPassword);
+      prototype.registerHybridGetter("discardPaths", &HybridZipSpec::getDiscardPaths);
+      prototype.registerHybridSetter("discardPaths", &HybridZipSpec::setDiscardPaths);
+      prototype.registerHybridGetter("encryptKeyLength", &HybridZipSpec::getEncryptKeyLength);
+      prototype.registerHybridSetter("encryptKeyLength", &HybridZipSpec::setEncryptKeyLength);
+      prototype.registerHybridGetter("encryptPassword", &HybridZipSpec::getEncryptPassword);
+      prototype.registerHybridSetter("encryptPassword", &HybridZipSpec::setEncryptPassword);
+      prototype.registerHybridGetter("encryption", &HybridZipSpec::getEncryption);
+      prototype.registerHybridSetter("encryption", &HybridZipSpec::setEncryption);
+      prototype.registerHybridGetter("exeDefaultDir", &HybridZipSpec::getExeDefaultDir);
+      prototype.registerHybridSetter("exeDefaultDir", &HybridZipSpec::setExeDefaultDir);
+      prototype.registerHybridGetter("exeFinishNotifier", &HybridZipSpec::getExeFinishNotifier);
+      prototype.registerHybridSetter("exeFinishNotifier", &HybridZipSpec::setExeFinishNotifier);
+      prototype.registerHybridGetter("exeIconFile", &HybridZipSpec::getExeIconFile);
+      prototype.registerHybridSetter("exeIconFile", &HybridZipSpec::setExeIconFile);
+      prototype.registerHybridGetter("exeNoInterface", &HybridZipSpec::getExeNoInterface);
+      prototype.registerHybridSetter("exeNoInterface", &HybridZipSpec::setExeNoInterface);
+      prototype.registerHybridGetter("exeSilentProgress", &HybridZipSpec::getExeSilentProgress);
+      prototype.registerHybridSetter("exeSilentProgress", &HybridZipSpec::setExeSilentProgress);
+      prototype.registerHybridGetter("exeTitle", &HybridZipSpec::getExeTitle);
+      prototype.registerHybridSetter("exeTitle", &HybridZipSpec::setExeTitle);
+      prototype.registerHybridGetter("exeUnzipCaption", &HybridZipSpec::getExeUnzipCaption);
+      prototype.registerHybridSetter("exeUnzipCaption", &HybridZipSpec::setExeUnzipCaption);
+      prototype.registerHybridGetter("exeUnzipDir", &HybridZipSpec::getExeUnzipDir);
+      prototype.registerHybridSetter("exeUnzipDir", &HybridZipSpec::setExeUnzipDir);
+      prototype.registerHybridGetter("exeWaitForSetup", &HybridZipSpec::getExeWaitForSetup);
+      prototype.registerHybridSetter("exeWaitForSetup", &HybridZipSpec::setExeWaitForSetup);
+      prototype.registerHybridGetter("exeXmlConfig", &HybridZipSpec::getExeXmlConfig);
+      prototype.registerHybridSetter("exeXmlConfig", &HybridZipSpec::setExeXmlConfig);
+      prototype.registerHybridGetter("fileCount", &HybridZipSpec::getFileCount);
+      prototype.registerHybridGetter("fileName", &HybridZipSpec::getFileName);
+      prototype.registerHybridSetter("fileName", &HybridZipSpec::setFileName);
+      prototype.registerHybridGetter("hasZipFormatErrors", &HybridZipSpec::getHasZipFormatErrors);
+      prototype.registerHybridGetter("heartbeatMs", &HybridZipSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridZipSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("ignoreAccessDenied", &HybridZipSpec::getIgnoreAccessDenied);
+      prototype.registerHybridSetter("ignoreAccessDenied", &HybridZipSpec::setIgnoreAccessDenied);
+      prototype.registerHybridGetter("numEntries", &HybridZipSpec::getNumEntries);
+      prototype.registerHybridGetter("oemCodePage", &HybridZipSpec::getOemCodePage);
+      prototype.registerHybridSetter("oemCodePage", &HybridZipSpec::setOemCodePage);
+      prototype.registerHybridGetter("overwriteExisting", &HybridZipSpec::getOverwriteExisting);
+      prototype.registerHybridSetter("overwriteExisting", &HybridZipSpec::setOverwriteExisting);
+      prototype.registerHybridGetter("passwordProtect", &HybridZipSpec::getPasswordProtect);
+      prototype.registerHybridSetter("passwordProtect", &HybridZipSpec::setPasswordProtect);
+      prototype.registerHybridGetter("pathPrefix", &HybridZipSpec::getPathPrefix);
+      prototype.registerHybridSetter("pathPrefix", &HybridZipSpec::setPathPrefix);
+      prototype.registerHybridGetter("percentDoneScale", &HybridZipSpec::getPercentDoneScale);
+      prototype.registerHybridSetter("percentDoneScale", &HybridZipSpec::setPercentDoneScale);
+      prototype.registerHybridGetter("tempDir", &HybridZipSpec::getTempDir);
+      prototype.registerHybridSetter("tempDir", &HybridZipSpec::setTempDir);
+      prototype.registerHybridGetter("zipx", &HybridZipSpec::getZipx);
+      prototype.registerHybridSetter("zipx", &HybridZipSpec::setZipx);
+      prototype.registerHybridGetter("zipxDefaultAlg", &HybridZipSpec::getZipxDefaultAlg);
+      prototype.registerHybridSetter("zipxDefaultAlg", &HybridZipSpec::setZipxDefaultAlg);
+      prototype.registerHybridGetter("pwdProtCharset", &HybridZipSpec::getPwdProtCharset);
+      prototype.registerHybridSetter("pwdProtCharset", &HybridZipSpec::setPwdProtCharset);
+      prototype.registerHybridGetter("uncommonOptions", &HybridZipSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridZipSpec::setUncommonOptions);
+      prototype.registerHybridGetter("maxUncompressSize", &HybridZipSpec::getMaxUncompressSize);
+      prototype.registerHybridSetter("maxUncompressSize", &HybridZipSpec::setMaxUncompressSize);
+      prototype.registerHybridGetter("minDate", &HybridZipSpec::getMinDate);
+      prototype.registerHybridSetter("minDate", &HybridZipSpec::setMinDate);
+      prototype.registerHybridGetter("maxDate", &HybridZipSpec::getMaxDate);
+      prototype.registerHybridSetter("maxDate", &HybridZipSpec::setMaxDate);
+      prototype.registerHybridGetter("onPercentDone", &HybridZipSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridZipSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridZipSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridZipSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("addNoCompressExtension", &HybridZipSpec::addNoCompressExtension);
+      prototype.registerHybridMethod("appendFiles", &HybridZipSpec::appendFiles);
+      prototype.registerHybridMethod("appendFilesAsync", &HybridZipSpec::appendFilesAsync);
+      prototype.registerHybridMethod("appendFilesEx", &HybridZipSpec::appendFilesEx);
+      prototype.registerHybridMethod("appendFilesExAsync", &HybridZipSpec::appendFilesExAsync);
+      prototype.registerHybridMethod("appendZip", &HybridZipSpec::appendZip);
+      prototype.registerHybridMethod("closeZip", &HybridZipSpec::closeZip);
+      prototype.registerHybridMethod("deleteEntry", &HybridZipSpec::deleteEntry);
+      prototype.registerHybridMethod("excludeDir", &HybridZipSpec::excludeDir);
+      prototype.registerHybridMethod("extractExe", &HybridZipSpec::extractExe);
+      prototype.registerHybridMethod("extractExeAsync", &HybridZipSpec::extractExeAsync);
+      prototype.registerHybridMethod("getDirectoryAsXML", &HybridZipSpec::getDirectoryAsXML);
+      prototype.registerHybridMethod("getExeConfigParam", &HybridZipSpec::getExeConfigParam);
+      prototype.registerHybridMethod("isNoCompressExtension", &HybridZipSpec::isNoCompressExtension);
+      prototype.registerHybridMethod("isPasswordProtected", &HybridZipSpec::isPasswordProtected);
+      prototype.registerHybridMethod("newZip", &HybridZipSpec::newZip);
+      prototype.registerHybridMethod("openEmbedded", &HybridZipSpec::openEmbedded);
+      prototype.registerHybridMethod("openZip", &HybridZipSpec::openZip);
+      prototype.registerHybridMethod("openZipAsync", &HybridZipSpec::openZipAsync);
+      prototype.registerHybridMethod("quickAppend", &HybridZipSpec::quickAppend);
+      prototype.registerHybridMethod("quickAppendAsync", &HybridZipSpec::quickAppendAsync);
+      prototype.registerHybridMethod("removeNoCompressExtension", &HybridZipSpec::removeNoCompressExtension);
+      prototype.registerHybridMethod("setCompressionLevel", &HybridZipSpec::setCompressionLevel);
+      prototype.registerHybridMethod("setExclusions", &HybridZipSpec::setExclusions);
+      prototype.registerHybridMethod("setExeConfigParam", &HybridZipSpec::setExeConfigParam);
+      prototype.registerHybridMethod("unzip", &HybridZipSpec::unzip);
+      prototype.registerHybridMethod("unzipAsync", &HybridZipSpec::unzipAsync);
+      prototype.registerHybridMethod("unzipInto", &HybridZipSpec::unzipInto);
+      prototype.registerHybridMethod("unzipIntoAsync", &HybridZipSpec::unzipIntoAsync);
+      prototype.registerHybridMethod("unzipMatching", &HybridZipSpec::unzipMatching);
+      prototype.registerHybridMethod("unzipMatchingAsync", &HybridZipSpec::unzipMatchingAsync);
+      prototype.registerHybridMethod("unzipMatchingInto", &HybridZipSpec::unzipMatchingInto);
+      prototype.registerHybridMethod("unzipMatchingIntoAsync", &HybridZipSpec::unzipMatchingIntoAsync);
+      prototype.registerHybridMethod("unzipNewer", &HybridZipSpec::unzipNewer);
+      prototype.registerHybridMethod("unzipNewerAsync", &HybridZipSpec::unzipNewerAsync);
+      prototype.registerHybridMethod("verifyPassword", &HybridZipSpec::verifyPassword);
+      prototype.registerHybridMethod("writeExe", &HybridZipSpec::writeExe);
+      prototype.registerHybridMethod("writeExeAsync", &HybridZipSpec::writeExeAsync);
+      prototype.registerHybridMethod("writeExe2", &HybridZipSpec::writeExe2);
+      prototype.registerHybridMethod("writeExe2Async", &HybridZipSpec::writeExe2Async);
+      prototype.registerHybridMethod("writeZip", &HybridZipSpec::writeZip);
+      prototype.registerHybridMethod("writeZipAsync", &HybridZipSpec::writeZipAsync);
+      prototype.registerHybridMethod("writeZipAndClose", &HybridZipSpec::writeZipAndClose);
+      prototype.registerHybridMethod("writeZipAndCloseAsync", &HybridZipSpec::writeZipAndCloseAsync);
+      prototype.registerHybridMethod("writeBd", &HybridZipSpec::writeBd);
+      prototype.registerHybridMethod("writeBdAsync", &HybridZipSpec::writeBdAsync);
+      prototype.registerHybridMethod("openBd", &HybridZipSpec::openBd);
+      prototype.registerHybridMethod("getMaxUncompressedSize", &HybridZipSpec::getMaxUncompressedSize);
+      prototype.registerHybridMethod("addBd", &HybridZipSpec::addBd);
+      prototype.registerHybridMethod("addEncoded", &HybridZipSpec::addEncoded);
+      prototype.registerHybridMethod("addEmpty", &HybridZipSpec::addEmpty);
+      prototype.registerHybridMethod("addString", &HybridZipSpec::addString);
+      prototype.registerHybridMethod("addSb", &HybridZipSpec::addSb);
+      prototype.registerHybridMethod("addFile", &HybridZipSpec::addFile);
+      prototype.registerHybridMethod("entryAt", &HybridZipSpec::entryAt);
+      prototype.registerHybridMethod("entryMatching", &HybridZipSpec::entryMatching);
+      prototype.registerHybridMethod("entryOf", &HybridZipSpec::entryOf);
+      prototype.registerHybridMethod("entryById", &HybridZipSpec::entryById);
+      prototype.registerHybridMethod("abort", &HybridZipSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridZipSpec.hpp

@@ -0,0 +1,231 @@
+///
+/// HybridZipSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridZipEntrySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridZipEntrySpec; }
+// Forward declaration of `HybridStringArraySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringArraySpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridZipEntrySpec.hpp"
+#include "HybridStringArraySpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Zip`
+   * Inherit this class to create instances of `HybridZipSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridZip: public HybridZipSpec {
+   * public:
+   *   HybridZip(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridZipSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridZipSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridZipSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual bool getAbortCurrent() = 0;
+      virtual void setAbortCurrent(bool abortCurrent) = 0;
+      virtual std::string getAppendFromDir() = 0;
+      virtual void setAppendFromDir(const std::string& appendFromDir) = 0;
+      virtual std::string getAutoRun() = 0;
+      virtual void setAutoRun(const std::string& autoRun) = 0;
+      virtual std::string getAutoRunParams() = 0;
+      virtual void setAutoRunParams(const std::string& autoRunParams) = 0;
+      virtual bool getAutoTemp() = 0;
+      virtual void setAutoTemp(bool autoTemp) = 0;
+      virtual bool getCaseSensitive() = 0;
+      virtual void setCaseSensitive(bool caseSensitive) = 0;
+      virtual bool getClearArchiveAttribute() = 0;
+      virtual void setClearArchiveAttribute(bool clearArchiveAttribute) = 0;
+      virtual bool getClearReadOnlyAttr() = 0;
+      virtual void setClearReadOnlyAttr(bool clearReadOnlyAttr) = 0;
+      virtual std::string getComment() = 0;
+      virtual void setComment(const std::string& comment) = 0;
+      virtual std::string getDecryptPassword() = 0;
+      virtual void setDecryptPassword(const std::string& decryptPassword) = 0;
+      virtual bool getDiscardPaths() = 0;
+      virtual void setDiscardPaths(bool discardPaths) = 0;
+      virtual double getEncryptKeyLength() = 0;
+      virtual void setEncryptKeyLength(double encryptKeyLength) = 0;
+      virtual std::string getEncryptPassword() = 0;
+      virtual void setEncryptPassword(const std::string& encryptPassword) = 0;
+      virtual double getEncryption() = 0;
+      virtual void setEncryption(double encryption) = 0;
+      virtual std::string getExeDefaultDir() = 0;
+      virtual void setExeDefaultDir(const std::string& exeDefaultDir) = 0;
+      virtual bool getExeFinishNotifier() = 0;
+      virtual void setExeFinishNotifier(bool exeFinishNotifier) = 0;
+      virtual std::string getExeIconFile() = 0;
+      virtual void setExeIconFile(const std::string& exeIconFile) = 0;
+      virtual bool getExeNoInterface() = 0;
+      virtual void setExeNoInterface(bool exeNoInterface) = 0;
+      virtual bool getExeSilentProgress() = 0;
+      virtual void setExeSilentProgress(bool exeSilentProgress) = 0;
+      virtual std::string getExeTitle() = 0;
+      virtual void setExeTitle(const std::string& exeTitle) = 0;
+      virtual std::string getExeUnzipCaption() = 0;
+      virtual void setExeUnzipCaption(const std::string& exeUnzipCaption) = 0;
+      virtual std::string getExeUnzipDir() = 0;
+      virtual void setExeUnzipDir(const std::string& exeUnzipDir) = 0;
+      virtual bool getExeWaitForSetup() = 0;
+      virtual void setExeWaitForSetup(bool exeWaitForSetup) = 0;
+      virtual std::string getExeXmlConfig() = 0;
+      virtual void setExeXmlConfig(const std::string& exeXmlConfig) = 0;
+      virtual double getFileCount() = 0;
+      virtual std::string getFileName() = 0;
+      virtual void setFileName(const std::string& fileName) = 0;
+      virtual bool getHasZipFormatErrors() = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual bool getIgnoreAccessDenied() = 0;
+      virtual void setIgnoreAccessDenied(bool ignoreAccessDenied) = 0;
+      virtual double getNumEntries() = 0;
+      virtual double getOemCodePage() = 0;
+      virtual void setOemCodePage(double oemCodePage) = 0;
+      virtual bool getOverwriteExisting() = 0;
+      virtual void setOverwriteExisting(bool overwriteExisting) = 0;
+      virtual bool getPasswordProtect() = 0;
+      virtual void setPasswordProtect(bool passwordProtect) = 0;
+      virtual std::string getPathPrefix() = 0;
+      virtual void setPathPrefix(const std::string& pathPrefix) = 0;
+      virtual double getPercentDoneScale() = 0;
+      virtual void setPercentDoneScale(double percentDoneScale) = 0;
+      virtual std::string getTempDir() = 0;
+      virtual void setTempDir(const std::string& tempDir) = 0;
+      virtual bool getZipx() = 0;
+      virtual void setZipx(bool zipx) = 0;
+      virtual std::string getZipxDefaultAlg() = 0;
+      virtual void setZipxDefaultAlg(const std::string& zipxDefaultAlg) = 0;
+      virtual std::string getPwdProtCharset() = 0;
+      virtual void setPwdProtCharset(const std::string& pwdProtCharset) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual double getMaxUncompressSize() = 0;
+      virtual void setMaxUncompressSize(double maxUncompressSize) = 0;
+      virtual std::string getMinDate() = 0;
+      virtual void setMinDate(const std::string& minDate) = 0;
+      virtual std::string getMaxDate() = 0;
+      virtual void setMaxDate(const std::string& maxDate) = 0;
+      virtual std::optional<std::function<void(double /* pctDone */)>> getOnPercentDone() = 0;
+      virtual void setOnPercentDone(const std::optional<std::function<void(double /* pctDone */)>>& onPercentDone) = 0;
+      virtual std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>> getOnProgressInfo() = 0;
+      virtual void setOnProgressInfo(const std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>>& onProgressInfo) = 0;
+
+    public:
+      // Methods
+      virtual void addNoCompressExtension(const std::string& fileExtension) = 0;
+      virtual void appendFiles(const std::string& filePattern, bool recurse) = 0;
+      virtual std::shared_ptr<Promise<void>> appendFilesAsync(const std::string& filePattern, bool recurse) = 0;
+      virtual void appendFilesEx(const std::string& filePattern, bool recurse, bool saveExtraPath, bool archiveOnly, bool includeHidden, bool includeSystem) = 0;
+      virtual std::shared_ptr<Promise<void>> appendFilesExAsync(const std::string& filePattern, bool recurse, bool saveExtraPath, bool archiveOnly, bool includeHidden, bool includeSystem) = 0;
+      virtual void appendZip(const std::string& zipPath) = 0;
+      virtual void closeZip() = 0;
+      virtual void deleteEntry(const std::shared_ptr<HybridZipEntrySpec>& entry) = 0;
+      virtual void excludeDir(const std::string& dirName) = 0;
+      virtual void extractExe(const std::string& exePath, const std::string& dirPath) = 0;
+      virtual std::shared_ptr<Promise<void>> extractExeAsync(const std::string& exePath, const std::string& dirPath) = 0;
+      virtual std::string getDirectoryAsXML() = 0;
+      virtual std::string getExeConfigParam(const std::string& name) = 0;
+      virtual bool isNoCompressExtension(const std::string& fileExtension) = 0;
+      virtual bool isPasswordProtected(const std::string& zipPath) = 0;
+      virtual void newZip(const std::string& zipPath) = 0;
+      virtual void openEmbedded(const std::string& exeFilename, const std::string& resourceName) = 0;
+      virtual void openZip(const std::string& zipPath) = 0;
+      virtual std::shared_ptr<Promise<void>> openZipAsync(const std::string& zipPath) = 0;
+      virtual void quickAppend(const std::string& zipPath) = 0;
+      virtual std::shared_ptr<Promise<void>> quickAppendAsync(const std::string& zipPath) = 0;
+      virtual void removeNoCompressExtension(const std::string& fileExtension) = 0;
+      virtual void setCompressionLevel(double level) = 0;
+      virtual void setExclusions(const std::shared_ptr<HybridStringArraySpec>& excludePatterns) = 0;
+      virtual void setExeConfigParam(const std::string& paramName, const std::string& paramValue) = 0;
+      virtual double unzip(const std::string& dirPath) = 0;
+      virtual std::shared_ptr<Promise<double>> unzipAsync(const std::string& dirPath) = 0;
+      virtual double unzipInto(const std::string& dirPath) = 0;
+      virtual std::shared_ptr<Promise<double>> unzipIntoAsync(const std::string& dirPath) = 0;
+      virtual double unzipMatching(const std::string& dirPath, const std::string& pattern, bool verbose) = 0;
+      virtual std::shared_ptr<Promise<double>> unzipMatchingAsync(const std::string& dirPath, const std::string& pattern, bool verbose) = 0;
+      virtual double unzipMatchingInto(const std::string& dirPath, const std::string& pattern, bool verbose) = 0;
+      virtual std::shared_ptr<Promise<double>> unzipMatchingIntoAsync(const std::string& dirPath, const std::string& pattern, bool verbose) = 0;
+      virtual double unzipNewer(const std::string& dirPath) = 0;
+      virtual std::shared_ptr<Promise<double>> unzipNewerAsync(const std::string& dirPath) = 0;
+      virtual bool verifyPassword() = 0;
+      virtual void writeExe(const std::string& exeFilename) = 0;
+      virtual std::shared_ptr<Promise<void>> writeExeAsync(const std::string& exeFilename) = 0;
+      virtual void writeExe2(const std::string& exePath, const std::string& destExePath, bool bAesEncrypt, double keyLength, const std::string& password) = 0;
+      virtual std::shared_ptr<Promise<void>> writeExe2Async(const std::string& exePath, const std::string& destExePath, bool bAesEncrypt, double keyLength, const std::string& password) = 0;
+      virtual void writeZip() = 0;
+      virtual std::shared_ptr<Promise<void>> writeZipAsync() = 0;
+      virtual void writeZipAndClose() = 0;
+      virtual std::shared_ptr<Promise<void>> writeZipAndCloseAsync() = 0;
+      virtual void writeBd(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual std::shared_ptr<Promise<void>> writeBdAsync(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual void openBd(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual std::string getMaxUncompressedSize() = 0;
+      virtual void addBd(const std::string& pathInZip, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void addEncoded(const std::string& pathInZip, const std::string& encoding, const std::string& data) = 0;
+      virtual void addEmpty(bool isDir, const std::string& pathInZip) = 0;
+      virtual void addString(const std::string& pathInZip, const std::string& content, const std::string& charset) = 0;
+      virtual void addSb(const std::string& pathInZip, const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) = 0;
+      virtual void addFile(const std::string& localPath, bool saveExtraPath) = 0;
+      virtual void entryAt(double index, const std::shared_ptr<HybridZipEntrySpec>& entry) = 0;
+      virtual void entryMatching(const std::string& pattern, const std::shared_ptr<HybridZipEntrySpec>& entry) = 0;
+      virtual bool entryOf(const std::string& pathInZip, const std::shared_ptr<HybridZipEntrySpec>& entry) = 0;
+      virtual void entryById(double id, const std::shared_ptr<HybridZipEntrySpec>& entry) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Zip";
+  };
+
+} // namespace margelo::nitro::chilkat

package/package.json

@@ -0,0 +1,46 @@
+{
+  "_generated": "Generated by ReactNativeNs.RnGenerator -- do not edit (the version comes from generateForMicroVersion.txt)",
+  "name": "@chilkat/react-native",
+  "version": "11.6.1",
+  "description": "The Chilkat class library for React Native (a Nitro Module): HTTP, REST, email (SMTP/POP3/IMAP), FTP, SFTP, SSH, zip, encryption, digital signatures, certificates, XML, JSON and more.",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "react-native": "src/index.ts",
+  "files": [
+    "src",
+    "cpp",
+    "nitrogen/generated",
+    "android",
+    "scripts",
+    "*.podspec",
+    "react-native.config.js",
+    "nitro.json",
+    "chilkat-checksums.json",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE",
+    "THIRD-PARTY-NOTICES.txt",
+    "!android/build",
+    "!android/.cxx",
+    "!**/native"
+  ],
+  "scripts": {
+    "nitrogen": "nitrogen",
+    "typecheck": "tsc --noEmit",
+    "fetch-chilkat": "node scripts/fetch-chilkat.js"
+  },
+  "keywords": ["react-native", "expo", "nitro", "chilkat", "http", "rest", "email", "imap", "smtp", "ftp", "sftp", "ssh", "zip", "encryption", "rsa", "aes", "certificates", "xml", "json"],
+  "homepage": "https://www.chilkatsoft.com/",
+  "bugs": { "url": "https://www.chilkatsoft.com/support.asp" },
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "Chilkat Software, Inc.",
+  "peerDependencies": {
+    "react-native": ">=0.76",
+    "react-native-nitro-modules": "^0.37.0"
+  },
+  "devDependencies": {
+    "nitrogen": "^0.37.0",
+    "react-native-nitro-modules": "^0.37.0",
+    "typescript": "^5.5.0"
+  }
+}

package/react-native.config.js

@@ -0,0 +1,9 @@
+// https://github.com/react-native-community/cli/blob/main/docs/dependencies.md
+module.exports = {
+  dependency: {
+    platforms: {
+      ios: {},
+      android: {},
+    },
+  },
+}