@chilkat/react-native 11.6.1

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

@@ -0,0 +1,156 @@
+///
+/// HybridStringBuilderSpec.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 `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+// Forward declaration of `HybridStringTableSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringTableSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+#include "HybridStringTableSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `StringBuilder`
+   * Inherit this class to create instances of `HybridStringBuilderSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridStringBuilder: public HybridStringBuilderSpec {
+   * public:
+   *   HybridStringBuilder(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridStringBuilderSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridStringBuilderSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridStringBuilderSpec() 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 double getLength() = 0;
+      virtual double getIntValue() = 0;
+      virtual void setIntValue(double intValue) = 0;
+      virtual bool getIsBase64() = 0;
+      virtual bool getHasEmojis() = 0;
+
+    public:
+      // Methods
+      virtual void append(const std::string& value) = 0;
+      virtual void appendInt(double value) = 0;
+      virtual void appendInt64(double value) = 0;
+      virtual void clear() = 0;
+      virtual double replace(const std::string& value, const std::string& replacement) = 0;
+      virtual std::string getAsString() = 0;
+      virtual bool contentsEqual(const std::string& str, bool caseSensitive) = 0;
+      virtual bool contains(const std::string& str, bool caseSensitive) = 0;
+      virtual bool isWellFormed(const std::string& format) = 0;
+      virtual void prepend(const std::string& value) = 0;
+      virtual void setString(const std::string& value) = 0;
+      virtual void encode(const std::string& encoding, const std::string& charset) = 0;
+      virtual std::string getEncoded(const std::string& encoding, const std::string& charset) = 0;
+      virtual void decode(const std::string& encoding, const std::string& charset) = 0;
+      virtual void trim() = 0;
+      virtual void trimInsideSpaces() = 0;
+      virtual bool startsWith(const std::string& substr, bool caseSensitive) = 0;
+      virtual bool endsWith(const std::string& substr, bool caseSensitive) = 0;
+      virtual void toLowercase() = 0;
+      virtual void toUppercase() = 0;
+      virtual void toCRLF() = 0;
+      virtual void toLF() = 0;
+      virtual void entityDecode() = 0;
+      virtual double replaceWord(const std::string& value, const std::string& replacement) = 0;
+      virtual double replaceBetween(const std::string& beginMark, const std::string& endMark, const std::string& value, const std::string& replacement) = 0;
+      virtual std::string getBetween(const std::string& beginMark, const std::string& endMark) = 0;
+      virtual std::string getAfterBetween(const std::string& searchAfter, const std::string& beginMark, const std::string& endMark) = 0;
+      virtual std::string getNth(double index, const std::string& delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped) = 0;
+      virtual void setNth(double index, const std::string& value, const std::string& delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped) = 0;
+      virtual void loadFile(const std::string& path, const std::string& charset) = 0;
+      virtual void writeFile(const std::string& path, const std::string& charset, bool emitBom) = 0;
+      virtual void appendSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual bool contentsEqualSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool caseSensitive) = 0;
+      virtual std::string lastNLines(double numLines, bool bCrlf) = 0;
+      virtual void appendBd(const std::shared_ptr<HybridBinDataSpec>& binData, const std::string& charset, double offset, double numBytes) = 0;
+      virtual void replaceAllBetween(const std::string& beginMark, const std::string& endMark, const std::string& replacement, bool replaceMarks) = 0;
+      virtual void appendLine(const std::string& str, bool crlf) = 0;
+      virtual void secureClear() = 0;
+      virtual double replaceI(const std::string& value, double replacement) = 0;
+      virtual bool containsWord(const std::string& word, bool caseSensitive) = 0;
+      virtual void punyEncode() = 0;
+      virtual void punyDecode() = 0;
+      virtual void replaceAfterFinal(const std::string& marker, const std::string& replacement) = 0;
+      virtual void writeFileIfModified(const std::string& path, const std::string& charset, bool emitBom) = 0;
+      virtual std::string getBefore(const std::string& marker, bool removeFlag) = 0;
+      virtual void removeBefore(const std::string& marker) = 0;
+      virtual void replaceFirst(const std::string& value, const std::string& replacement) = 0;
+      virtual std::string getAfterFinal(const std::string& marker, bool removeFlag) = 0;
+      virtual void removeAfterFinal(const std::string& marker) = 0;
+      virtual void obfuscate() = 0;
+      virtual void unobfuscate() = 0;
+      virtual double replaceNoCase(const std::string& value, const std::string& replacement) = 0;
+      virtual void decodeAndAppend(const std::string& value, const std::string& encoding, const std::string& charset) = 0;
+      virtual void shorten(double numChars) = 0;
+      virtual void removeCharsAt(double startIndex, double numChars) = 0;
+      virtual std::string getRange(double startIndex, double numChars, bool removeFlag) = 0;
+      virtual std::string getHash(const std::string& algorithm, const std::string& encoding, const std::string& charset) = 0;
+      virtual void removeAccents() = 0;
+      virtual void appendUuid(bool lowerCase) = 0;
+      virtual void appendRandom(double numBytes, const std::string& encoding) = 0;
+      virtual void appendUuid7(bool lowerCase) = 0;
+      virtual void removeEmojis() = 0;
+      virtual double regexMatch(const std::string& pattern, const std::shared_ptr<HybridJsonObjectSpec>& json, double timeoutMs) = 0;
+      virtual void regexReplace(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void maskQuotedStrings(const std::string& maskChar, double quoteType, const std::shared_ptr<HybridStringTableSpec>& maskedStrings) = 0;
+      virtual void restoreMaskedStrings(double quoteType, const std::shared_ptr<HybridStringTableSpec>& maskedStrings) = 0;
+      virtual void markdownToHtml(const std::shared_ptr<HybridJsonObjectSpec>& options, const std::shared_ptr<HybridStringBuilderSpec>& sbHtml) = 0;
+      virtual void getRangeSb(double startIndex, double numChars, bool removeFlag, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void appendLn(const std::string& str) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "StringBuilder";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,46 @@
+///
+/// HybridStringTableSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridStringTableSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridStringTableSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridStringTableSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridStringTableSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridStringTableSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridStringTableSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridStringTableSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridStringTableSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridStringTableSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridStringTableSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridStringTableSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridStringTableSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("count", &HybridStringTableSpec::getCount);
+      prototype.registerHybridMethod("appendFromFile", &HybridStringTableSpec::appendFromFile);
+      prototype.registerHybridMethod("append", &HybridStringTableSpec::append);
+      prototype.registerHybridMethod("stringAt", &HybridStringTableSpec::stringAt);
+      prototype.registerHybridMethod("saveToFile", &HybridStringTableSpec::saveToFile);
+      prototype.registerHybridMethod("splitAndAppend", &HybridStringTableSpec::splitAndAppend);
+      prototype.registerHybridMethod("appendFromSb", &HybridStringTableSpec::appendFromSb);
+      prototype.registerHybridMethod("clear", &HybridStringTableSpec::clear);
+      prototype.registerHybridMethod("intAt", &HybridStringTableSpec::intAt);
+      prototype.registerHybridMethod("findSubstring", &HybridStringTableSpec::findSubstring);
+      prototype.registerHybridMethod("sort", &HybridStringTableSpec::sort);
+      prototype.registerHybridMethod("getStrings", &HybridStringTableSpec::getStrings);
+      prototype.registerHybridMethod("findMatch", &HybridStringTableSpec::findMatch);
+      prototype.registerHybridMethod("wordFollowing", &HybridStringTableSpec::wordFollowing);
+      prototype.registerHybridMethod("stringAtSb", &HybridStringTableSpec::stringAtSb);
+      prototype.registerHybridMethod("toSb", &HybridStringTableSpec::toSb);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,89 @@
+///
+/// HybridStringTableSpec.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 `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridStringBuilderSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `StringTable`
+   * Inherit this class to create instances of `HybridStringTableSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridStringTable: public HybridStringTableSpec {
+   * public:
+   *   HybridStringTable(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridStringTableSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridStringTableSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridStringTableSpec() 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 double getCount() = 0;
+
+    public:
+      // Methods
+      virtual void appendFromFile(double maxLineLen, const std::string& charset, const std::string& path) = 0;
+      virtual void append(const std::string& value) = 0;
+      virtual std::string stringAt(double index) = 0;
+      virtual void saveToFile(const std::string& charset, bool bCrlf, const std::string& path) = 0;
+      virtual void splitAndAppend(const std::string& inStr, const std::string& delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped) = 0;
+      virtual void appendFromSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void clear() = 0;
+      virtual double intAt(double index) = 0;
+      virtual double findSubstring(double startIndex, const std::string& substr, bool caseSensitive) = 0;
+      virtual void sort(bool ascending, bool caseSensitive) = 0;
+      virtual std::string getStrings(double startIdx, double count, bool crlf) = 0;
+      virtual double findMatch(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool caseSensitive) = 0;
+      virtual double wordFollowing(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool captureEmailAddr, const std::shared_ptr<HybridStringBuilderSpec>& sbWord) = 0;
+      virtual void stringAtSb(double index, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void toSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "StringTable";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,110 @@
+///
+/// HybridTarSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridTarSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridTarSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridTarSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridTarSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridTarSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridTarSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridTarSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridTarSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridTarSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridTarSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridTarSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridTarSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("captureXmlListing", &HybridTarSpec::getCaptureXmlListing);
+      prototype.registerHybridSetter("captureXmlListing", &HybridTarSpec::setCaptureXmlListing);
+      prototype.registerHybridGetter("charset", &HybridTarSpec::getCharset);
+      prototype.registerHybridSetter("charset", &HybridTarSpec::setCharset);
+      prototype.registerHybridGetter("dirMode", &HybridTarSpec::getDirMode);
+      prototype.registerHybridSetter("dirMode", &HybridTarSpec::setDirMode);
+      prototype.registerHybridGetter("dirPrefix", &HybridTarSpec::getDirPrefix);
+      prototype.registerHybridSetter("dirPrefix", &HybridTarSpec::setDirPrefix);
+      prototype.registerHybridGetter("fileMode", &HybridTarSpec::getFileMode);
+      prototype.registerHybridSetter("fileMode", &HybridTarSpec::setFileMode);
+      prototype.registerHybridGetter("groupId", &HybridTarSpec::getGroupId);
+      prototype.registerHybridSetter("groupId", &HybridTarSpec::setGroupId);
+      prototype.registerHybridGetter("groupName", &HybridTarSpec::getGroupName);
+      prototype.registerHybridSetter("groupName", &HybridTarSpec::setGroupName);
+      prototype.registerHybridGetter("heartbeatMs", &HybridTarSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridTarSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("matchCaseSensitive", &HybridTarSpec::getMatchCaseSensitive);
+      prototype.registerHybridSetter("matchCaseSensitive", &HybridTarSpec::setMatchCaseSensitive);
+      prototype.registerHybridGetter("mustMatch", &HybridTarSpec::getMustMatch);
+      prototype.registerHybridSetter("mustMatch", &HybridTarSpec::setMustMatch);
+      prototype.registerHybridGetter("mustNotMatch", &HybridTarSpec::getMustNotMatch);
+      prototype.registerHybridSetter("mustNotMatch", &HybridTarSpec::setMustNotMatch);
+      prototype.registerHybridGetter("noAbsolutePaths", &HybridTarSpec::getNoAbsolutePaths);
+      prototype.registerHybridSetter("noAbsolutePaths", &HybridTarSpec::setNoAbsolutePaths);
+      prototype.registerHybridGetter("numDirRoots", &HybridTarSpec::getNumDirRoots);
+      prototype.registerHybridGetter("percentDoneScale", &HybridTarSpec::getPercentDoneScale);
+      prototype.registerHybridSetter("percentDoneScale", &HybridTarSpec::setPercentDoneScale);
+      prototype.registerHybridGetter("scriptFileMode", &HybridTarSpec::getScriptFileMode);
+      prototype.registerHybridSetter("scriptFileMode", &HybridTarSpec::setScriptFileMode);
+      prototype.registerHybridGetter("suppressOutput", &HybridTarSpec::getSuppressOutput);
+      prototype.registerHybridSetter("suppressOutput", &HybridTarSpec::setSuppressOutput);
+      prototype.registerHybridGetter("untarCaseSensitive", &HybridTarSpec::getUntarCaseSensitive);
+      prototype.registerHybridSetter("untarCaseSensitive", &HybridTarSpec::setUntarCaseSensitive);
+      prototype.registerHybridGetter("untarDebugLog", &HybridTarSpec::getUntarDebugLog);
+      prototype.registerHybridSetter("untarDebugLog", &HybridTarSpec::setUntarDebugLog);
+      prototype.registerHybridGetter("untarDiscardPaths", &HybridTarSpec::getUntarDiscardPaths);
+      prototype.registerHybridSetter("untarDiscardPaths", &HybridTarSpec::setUntarDiscardPaths);
+      prototype.registerHybridGetter("untarFromDir", &HybridTarSpec::getUntarFromDir);
+      prototype.registerHybridSetter("untarFromDir", &HybridTarSpec::setUntarFromDir);
+      prototype.registerHybridGetter("untarMaxCount", &HybridTarSpec::getUntarMaxCount);
+      prototype.registerHybridSetter("untarMaxCount", &HybridTarSpec::setUntarMaxCount);
+      prototype.registerHybridGetter("userId", &HybridTarSpec::getUserId);
+      prototype.registerHybridSetter("userId", &HybridTarSpec::setUserId);
+      prototype.registerHybridGetter("userName", &HybridTarSpec::getUserName);
+      prototype.registerHybridSetter("userName", &HybridTarSpec::setUserName);
+      prototype.registerHybridGetter("writeFormat", &HybridTarSpec::getWriteFormat);
+      prototype.registerHybridSetter("writeFormat", &HybridTarSpec::setWriteFormat);
+      prototype.registerHybridGetter("xmlListing", &HybridTarSpec::getXmlListing);
+      prototype.registerHybridSetter("xmlListing", &HybridTarSpec::setXmlListing);
+      prototype.registerHybridGetter("onPercentDone", &HybridTarSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridTarSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridTarSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridTarSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("addDirRoot", &HybridTarSpec::addDirRoot);
+      prototype.registerHybridMethod("addFile", &HybridTarSpec::addFile);
+      prototype.registerHybridMethod("getDirRoot", &HybridTarSpec::getDirRoot);
+      prototype.registerHybridMethod("listXml", &HybridTarSpec::listXml);
+      prototype.registerHybridMethod("listXmlAsync", &HybridTarSpec::listXmlAsync);
+      prototype.registerHybridMethod("untar", &HybridTarSpec::untar);
+      prototype.registerHybridMethod("untarAsync", &HybridTarSpec::untarAsync);
+      prototype.registerHybridMethod("untarBz2", &HybridTarSpec::untarBz2);
+      prototype.registerHybridMethod("untarBz2Async", &HybridTarSpec::untarBz2Async);
+      prototype.registerHybridMethod("untarGz", &HybridTarSpec::untarGz);
+      prototype.registerHybridMethod("untarGzAsync", &HybridTarSpec::untarGzAsync);
+      prototype.registerHybridMethod("untarZ", &HybridTarSpec::untarZ);
+      prototype.registerHybridMethod("untarZAsync", &HybridTarSpec::untarZAsync);
+      prototype.registerHybridMethod("verifyTar", &HybridTarSpec::verifyTar);
+      prototype.registerHybridMethod("verifyTarAsync", &HybridTarSpec::verifyTarAsync);
+      prototype.registerHybridMethod("writeTar", &HybridTarSpec::writeTar);
+      prototype.registerHybridMethod("writeTarAsync", &HybridTarSpec::writeTarAsync);
+      prototype.registerHybridMethod("writeTarBz2", &HybridTarSpec::writeTarBz2);
+      prototype.registerHybridMethod("writeTarBz2Async", &HybridTarSpec::writeTarBz2Async);
+      prototype.registerHybridMethod("writeTarGz", &HybridTarSpec::writeTarGz);
+      prototype.registerHybridMethod("writeTarGzAsync", &HybridTarSpec::writeTarGzAsync);
+      prototype.registerHybridMethod("addDirRoot2", &HybridTarSpec::addDirRoot2);
+      prototype.registerHybridMethod("createDeb", &HybridTarSpec::createDeb);
+      prototype.registerHybridMethod("addFile2", &HybridTarSpec::addFile2);
+      prototype.registerHybridMethod("untarFirstMatchingToBd", &HybridTarSpec::untarFirstMatchingToBd);
+      prototype.registerHybridMethod("clearDirRootsAndFiles", &HybridTarSpec::clearDirRootsAndFiles);
+      prototype.registerHybridMethod("abort", &HybridTarSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,156 @@
+///
+/// HybridTarSpec.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 `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridBinDataSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Tar`
+   * Inherit this class to create instances of `HybridTarSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridTar: public HybridTarSpec {
+   * public:
+   *   HybridTar(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridTarSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridTarSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridTarSpec() 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 getCaptureXmlListing() = 0;
+      virtual void setCaptureXmlListing(bool captureXmlListing) = 0;
+      virtual std::string getCharset() = 0;
+      virtual void setCharset(const std::string& charset) = 0;
+      virtual double getDirMode() = 0;
+      virtual void setDirMode(double dirMode) = 0;
+      virtual std::string getDirPrefix() = 0;
+      virtual void setDirPrefix(const std::string& dirPrefix) = 0;
+      virtual double getFileMode() = 0;
+      virtual void setFileMode(double fileMode) = 0;
+      virtual double getGroupId() = 0;
+      virtual void setGroupId(double groupId) = 0;
+      virtual std::string getGroupName() = 0;
+      virtual void setGroupName(const std::string& groupName) = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual bool getMatchCaseSensitive() = 0;
+      virtual void setMatchCaseSensitive(bool matchCaseSensitive) = 0;
+      virtual std::string getMustMatch() = 0;
+      virtual void setMustMatch(const std::string& mustMatch) = 0;
+      virtual std::string getMustNotMatch() = 0;
+      virtual void setMustNotMatch(const std::string& mustNotMatch) = 0;
+      virtual bool getNoAbsolutePaths() = 0;
+      virtual void setNoAbsolutePaths(bool noAbsolutePaths) = 0;
+      virtual double getNumDirRoots() = 0;
+      virtual double getPercentDoneScale() = 0;
+      virtual void setPercentDoneScale(double percentDoneScale) = 0;
+      virtual double getScriptFileMode() = 0;
+      virtual void setScriptFileMode(double scriptFileMode) = 0;
+      virtual bool getSuppressOutput() = 0;
+      virtual void setSuppressOutput(bool suppressOutput) = 0;
+      virtual bool getUntarCaseSensitive() = 0;
+      virtual void setUntarCaseSensitive(bool untarCaseSensitive) = 0;
+      virtual bool getUntarDebugLog() = 0;
+      virtual void setUntarDebugLog(bool untarDebugLog) = 0;
+      virtual bool getUntarDiscardPaths() = 0;
+      virtual void setUntarDiscardPaths(bool untarDiscardPaths) = 0;
+      virtual std::string getUntarFromDir() = 0;
+      virtual void setUntarFromDir(const std::string& untarFromDir) = 0;
+      virtual double getUntarMaxCount() = 0;
+      virtual void setUntarMaxCount(double untarMaxCount) = 0;
+      virtual double getUserId() = 0;
+      virtual void setUserId(double userId) = 0;
+      virtual std::string getUserName() = 0;
+      virtual void setUserName(const std::string& userName) = 0;
+      virtual std::string getWriteFormat() = 0;
+      virtual void setWriteFormat(const std::string& writeFormat) = 0;
+      virtual std::string getXmlListing() = 0;
+      virtual void setXmlListing(const std::string& xmlListing) = 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 addDirRoot(const std::string& dirPath) = 0;
+      virtual void addFile(const std::string& path) = 0;
+      virtual std::string getDirRoot(double index) = 0;
+      virtual std::string listXml(const std::string& tarPath) = 0;
+      virtual std::shared_ptr<Promise<std::string>> listXmlAsync(const std::string& tarPath) = 0;
+      virtual double untar(const std::string& tarPath) = 0;
+      virtual std::shared_ptr<Promise<double>> untarAsync(const std::string& tarPath) = 0;
+      virtual void untarBz2(const std::string& tarPath) = 0;
+      virtual std::shared_ptr<Promise<void>> untarBz2Async(const std::string& tarPath) = 0;
+      virtual void untarGz(const std::string& tarPath) = 0;
+      virtual std::shared_ptr<Promise<void>> untarGzAsync(const std::string& tarPath) = 0;
+      virtual void untarZ(const std::string& tarPath) = 0;
+      virtual std::shared_ptr<Promise<void>> untarZAsync(const std::string& tarPath) = 0;
+      virtual bool verifyTar(const std::string& tarPath) = 0;
+      virtual std::shared_ptr<Promise<bool>> verifyTarAsync(const std::string& tarPath) = 0;
+      virtual void writeTar(const std::string& tarPath) = 0;
+      virtual std::shared_ptr<Promise<void>> writeTarAsync(const std::string& tarPath) = 0;
+      virtual void writeTarBz2(const std::string& bz2Path) = 0;
+      virtual std::shared_ptr<Promise<void>> writeTarBz2Async(const std::string& bz2Path) = 0;
+      virtual void writeTarGz(const std::string& gzPath) = 0;
+      virtual std::shared_ptr<Promise<void>> writeTarGzAsync(const std::string& gzPath) = 0;
+      virtual void addDirRoot2(const std::string& rootPrefix, const std::string& rootPath) = 0;
+      virtual void createDeb(const std::string& controlPath, const std::string& dataPath, const std::string& debPath) = 0;
+      virtual void addFile2(const std::string& filePath, const std::string& pathWithinTar) = 0;
+      virtual void untarFirstMatchingToBd(const std::string& tarPath, const std::string& matchPattern, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void clearDirRootsAndFiles() = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Tar";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,48 @@
+///
+/// HybridTrustedRootsSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridTrustedRootsSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridTrustedRootsSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridTrustedRootsSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridTrustedRootsSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridTrustedRootsSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridTrustedRootsSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridTrustedRootsSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridTrustedRootsSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridTrustedRootsSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridTrustedRootsSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridTrustedRootsSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridTrustedRootsSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("numCerts", &HybridTrustedRootsSpec::getNumCerts);
+      prototype.registerHybridGetter("trustSystemCaRoots", &HybridTrustedRootsSpec::getTrustSystemCaRoots);
+      prototype.registerHybridSetter("trustSystemCaRoots", &HybridTrustedRootsSpec::setTrustSystemCaRoots);
+      prototype.registerHybridGetter("rejectSelfSignedCerts", &HybridTrustedRootsSpec::getRejectSelfSignedCerts);
+      prototype.registerHybridSetter("rejectSelfSignedCerts", &HybridTrustedRootsSpec::setRejectSelfSignedCerts);
+      prototype.registerHybridGetter("onPercentDone", &HybridTrustedRootsSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridTrustedRootsSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridTrustedRootsSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridTrustedRootsSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("activate", &HybridTrustedRootsSpec::activate);
+      prototype.registerHybridMethod("addCert", &HybridTrustedRootsSpec::addCert);
+      prototype.registerHybridMethod("addJavaKeyStore", &HybridTrustedRootsSpec::addJavaKeyStore);
+      prototype.registerHybridMethod("addJavaKeyStoreAsync", &HybridTrustedRootsSpec::addJavaKeyStoreAsync);
+      prototype.registerHybridMethod("deactivate", &HybridTrustedRootsSpec::deactivate);
+      prototype.registerHybridMethod("loadCaCertsPem", &HybridTrustedRootsSpec::loadCaCertsPem);
+      prototype.registerHybridMethod("loadCaCertsPemAsync", &HybridTrustedRootsSpec::loadCaCertsPemAsync);
+      prototype.registerHybridMethod("certAt", &HybridTrustedRootsSpec::certAt);
+      prototype.registerHybridMethod("abort", &HybridTrustedRootsSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat