@chilkat/react-native 11.6.1

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

@@ -0,0 +1,79 @@
+///
+/// HybridGzipSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridGzipSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridGzipSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridGzipSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridGzipSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridGzipSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridGzipSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridGzipSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridGzipSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridGzipSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridGzipSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridGzipSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridGzipSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("comment", &HybridGzipSpec::getComment);
+      prototype.registerHybridSetter("comment", &HybridGzipSpec::setComment);
+      prototype.registerHybridGetter("compressionLevel", &HybridGzipSpec::getCompressionLevel);
+      prototype.registerHybridSetter("compressionLevel", &HybridGzipSpec::setCompressionLevel);
+      prototype.registerHybridGetter("filename", &HybridGzipSpec::getFilename);
+      prototype.registerHybridSetter("filename", &HybridGzipSpec::setFilename);
+      prototype.registerHybridGetter("heartbeatMs", &HybridGzipSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridGzipSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("lastModStr", &HybridGzipSpec::getLastModStr);
+      prototype.registerHybridSetter("lastModStr", &HybridGzipSpec::setLastModStr);
+      prototype.registerHybridGetter("useCurrentDate", &HybridGzipSpec::getUseCurrentDate);
+      prototype.registerHybridSetter("useCurrentDate", &HybridGzipSpec::setUseCurrentDate);
+      prototype.registerHybridGetter("abortCurrent", &HybridGzipSpec::getAbortCurrent);
+      prototype.registerHybridSetter("abortCurrent", &HybridGzipSpec::setAbortCurrent);
+      prototype.registerHybridGetter("onPercentDone", &HybridGzipSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridGzipSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridGzipSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridGzipSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("compressFile", &HybridGzipSpec::compressFile);
+      prototype.registerHybridMethod("compressFileAsync", &HybridGzipSpec::compressFileAsync);
+      prototype.registerHybridMethod("compressFile2", &HybridGzipSpec::compressFile2);
+      prototype.registerHybridMethod("compressFile2Async", &HybridGzipSpec::compressFile2Async);
+      prototype.registerHybridMethod("compressStringENC", &HybridGzipSpec::compressStringENC);
+      prototype.registerHybridMethod("compressStringToFile", &HybridGzipSpec::compressStringToFile);
+      prototype.registerHybridMethod("compressStringToFileAsync", &HybridGzipSpec::compressStringToFileAsync);
+      prototype.registerHybridMethod("setDt", &HybridGzipSpec::setDt);
+      prototype.registerHybridMethod("unTarGz", &HybridGzipSpec::unTarGz);
+      prototype.registerHybridMethod("unTarGzAsync", &HybridGzipSpec::unTarGzAsync);
+      prototype.registerHybridMethod("uncompressFile", &HybridGzipSpec::uncompressFile);
+      prototype.registerHybridMethod("uncompressFileAsync", &HybridGzipSpec::uncompressFileAsync);
+      prototype.registerHybridMethod("uncompressFileToString", &HybridGzipSpec::uncompressFileToString);
+      prototype.registerHybridMethod("uncompressFileToStringAsync", &HybridGzipSpec::uncompressFileToStringAsync);
+      prototype.registerHybridMethod("uncompressStringENC", &HybridGzipSpec::uncompressStringENC);
+      prototype.registerHybridMethod("xfdlToXml", &HybridGzipSpec::xfdlToXml);
+      prototype.registerHybridMethod("uncompressBd", &HybridGzipSpec::uncompressBd);
+      prototype.registerHybridMethod("uncompressBdAsync", &HybridGzipSpec::uncompressBdAsync);
+      prototype.registerHybridMethod("compressBd", &HybridGzipSpec::compressBd);
+      prototype.registerHybridMethod("compressBdAsync", &HybridGzipSpec::compressBdAsync);
+      prototype.registerHybridMethod("setExtraData", &HybridGzipSpec::setExtraData);
+      prototype.registerHybridMethod("compressFileBd", &HybridGzipSpec::compressFileBd);
+      prototype.registerHybridMethod("compressFileBdAsync", &HybridGzipSpec::compressFileBdAsync);
+      prototype.registerHybridMethod("compressSb", &HybridGzipSpec::compressSb);
+      prototype.registerHybridMethod("compressSbAsync", &HybridGzipSpec::compressSbAsync);
+      prototype.registerHybridMethod("isGzip", &HybridGzipSpec::isGzip);
+      prototype.registerHybridMethod("uncompressBdToFile", &HybridGzipSpec::uncompressBdToFile);
+      prototype.registerHybridMethod("uncompressBdToFileAsync", &HybridGzipSpec::uncompressBdToFileAsync);
+      prototype.registerHybridMethod("getGzipInfo", &HybridGzipSpec::getGzipInfo);
+      prototype.registerHybridMethod("getGzipInfoBd", &HybridGzipSpec::getGzipInfoBd);
+      prototype.registerHybridMethod("abort", &HybridGzipSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,134 @@
+///
+/// HybridGzipSpec.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 `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; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridCkDateTimeSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Gzip`
+   * Inherit this class to create instances of `HybridGzipSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridGzip: public HybridGzipSpec {
+   * public:
+   *   HybridGzip(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridGzipSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridGzipSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridGzipSpec() 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 getCompressionLevel() = 0;
+      virtual void setCompressionLevel(double compressionLevel) = 0;
+      virtual std::string getFilename() = 0;
+      virtual void setFilename(const std::string& filename) = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual std::string getLastModStr() = 0;
+      virtual void setLastModStr(const std::string& lastModStr) = 0;
+      virtual bool getUseCurrentDate() = 0;
+      virtual void setUseCurrentDate(bool useCurrentDate) = 0;
+      virtual bool getAbortCurrent() = 0;
+      virtual void setAbortCurrent(bool abortCurrent) = 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 compressFile(const std::string& srcPath, const std::string& destPath) = 0;
+      virtual std::shared_ptr<Promise<void>> compressFileAsync(const std::string& srcPath, const std::string& destPath) = 0;
+      virtual void compressFile2(const std::string& srcPath, const std::string& embeddedFilename, const std::string& destPath) = 0;
+      virtual std::shared_ptr<Promise<void>> compressFile2Async(const std::string& srcPath, const std::string& embeddedFilename, const std::string& destPath) = 0;
+      virtual std::string compressStringENC(const std::string& inStr, const std::string& charset, const std::string& encoding) = 0;
+      virtual void compressStringToFile(const std::string& inStr, const std::string& destCharset, const std::string& destPath) = 0;
+      virtual std::shared_ptr<Promise<void>> compressStringToFileAsync(const std::string& inStr, const std::string& destCharset, const std::string& destPath) = 0;
+      virtual void setDt(const std::shared_ptr<HybridCkDateTimeSpec>& dt) = 0;
+      virtual void unTarGz(const std::string& gzPath, const std::string& destDir, bool bNoAbsolute) = 0;
+      virtual std::shared_ptr<Promise<void>> unTarGzAsync(const std::string& gzPath, const std::string& destDir, bool bNoAbsolute) = 0;
+      virtual void uncompressFile(const std::string& srcPath, const std::string& destPath) = 0;
+      virtual std::shared_ptr<Promise<void>> uncompressFileAsync(const std::string& srcPath, const std::string& destPath) = 0;
+      virtual std::string uncompressFileToString(const std::string& srcPath, const std::string& charset) = 0;
+      virtual std::shared_ptr<Promise<std::string>> uncompressFileToStringAsync(const std::string& srcPath, const std::string& charset) = 0;
+      virtual std::string uncompressStringENC(const std::string& inStr, const std::string& charset, const std::string& encoding) = 0;
+      virtual std::string xfdlToXml(const std::string& xfldData) = 0;
+      virtual void uncompressBd(const std::shared_ptr<HybridBinDataSpec>& binDat) = 0;
+      virtual std::shared_ptr<Promise<void>> uncompressBdAsync(const std::shared_ptr<HybridBinDataSpec>& binDat) = 0;
+      virtual void compressBd(const std::shared_ptr<HybridBinDataSpec>& binDat) = 0;
+      virtual std::shared_ptr<Promise<void>> compressBdAsync(const std::shared_ptr<HybridBinDataSpec>& binDat) = 0;
+      virtual void setExtraData(const std::string& encodedData, const std::string& encoding) = 0;
+      virtual void compressFileBd(const std::string& filePath, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual std::shared_ptr<Promise<void>> compressFileBdAsync(const std::string& filePath, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void compressSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual std::shared_ptr<Promise<void>> compressSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset, const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual bool isGzip(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void uncompressBdToFile(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filePath) = 0;
+      virtual std::shared_ptr<Promise<void>> uncompressBdToFileAsync(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filePath) = 0;
+      virtual void getGzipInfo(const std::string& filePath, const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void getGzipInfoBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Gzip";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,45 @@
+///
+/// HybridHashtableSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridHashtableSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridHashtableSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridHashtableSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridHashtableSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridHashtableSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridHashtableSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridHashtableSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridHashtableSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridHashtableSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridHashtableSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridHashtableSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridHashtableSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("count", &HybridHashtableSpec::getCount);
+      prototype.registerHybridMethod("addInt", &HybridHashtableSpec::addInt);
+      prototype.registerHybridMethod("addStr", &HybridHashtableSpec::addStr);
+      prototype.registerHybridMethod("clear", &HybridHashtableSpec::clear);
+      prototype.registerHybridMethod("clearWithNewCapacity", &HybridHashtableSpec::clearWithNewCapacity);
+      prototype.registerHybridMethod("contains", &HybridHashtableSpec::contains);
+      prototype.registerHybridMethod("lookupInt", &HybridHashtableSpec::lookupInt);
+      prototype.registerHybridMethod("lookupStr", &HybridHashtableSpec::lookupStr);
+      prototype.registerHybridMethod("remove", &HybridHashtableSpec::remove);
+      prototype.registerHybridMethod("getKeys", &HybridHashtableSpec::getKeys);
+      prototype.registerHybridMethod("addQueryParams", &HybridHashtableSpec::addQueryParams);
+      prototype.registerHybridMethod("toXmlSb", &HybridHashtableSpec::toXmlSb);
+      prototype.registerHybridMethod("addFromXmlSb", &HybridHashtableSpec::addFromXmlSb);
+      prototype.registerHybridMethod("containsIntKey", &HybridHashtableSpec::containsIntKey);
+      prototype.registerHybridMethod("toQueryString", &HybridHashtableSpec::toQueryString);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,91 @@
+///
+/// HybridHashtableSpec.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 `HybridStringTableSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringTableSpec; }
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridStringTableSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Hashtable`
+   * Inherit this class to create instances of `HybridHashtableSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridHashtable: public HybridHashtableSpec {
+   * public:
+   *   HybridHashtable(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridHashtableSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridHashtableSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridHashtableSpec() 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 addInt(const std::string& key, double value) = 0;
+      virtual void addStr(const std::string& key, const std::string& value) = 0;
+      virtual void clear() = 0;
+      virtual void clearWithNewCapacity(double capacity) = 0;
+      virtual bool contains(const std::string& key) = 0;
+      virtual double lookupInt(const std::string& key) = 0;
+      virtual std::string lookupStr(const std::string& key) = 0;
+      virtual void remove(const std::string& key) = 0;
+      virtual void getKeys(const std::shared_ptr<HybridStringTableSpec>& strTable) = 0;
+      virtual void addQueryParams(const std::string& queryParams) = 0;
+      virtual void toXmlSb(const std::shared_ptr<HybridStringBuilderSpec>& sbXml) = 0;
+      virtual void addFromXmlSb(const std::shared_ptr<HybridStringBuilderSpec>& sbXml) = 0;
+      virtual bool containsIntKey(double key) = 0;
+      virtual std::string toQueryString() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Hashtable";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,40 @@
+///
+/// HybridHtmlToTextSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridHtmlToTextSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridHtmlToTextSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridHtmlToTextSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridHtmlToTextSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridHtmlToTextSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridHtmlToTextSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridHtmlToTextSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridHtmlToTextSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridHtmlToTextSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridHtmlToTextSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridHtmlToTextSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridHtmlToTextSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("decodeHtmlEntities", &HybridHtmlToTextSpec::getDecodeHtmlEntities);
+      prototype.registerHybridSetter("decodeHtmlEntities", &HybridHtmlToTextSpec::setDecodeHtmlEntities);
+      prototype.registerHybridGetter("rightMargin", &HybridHtmlToTextSpec::getRightMargin);
+      prototype.registerHybridSetter("rightMargin", &HybridHtmlToTextSpec::setRightMargin);
+      prototype.registerHybridGetter("suppressLinks", &HybridHtmlToTextSpec::getSuppressLinks);
+      prototype.registerHybridSetter("suppressLinks", &HybridHtmlToTextSpec::setSuppressLinks);
+      prototype.registerHybridGetter("uncommonOptions", &HybridHtmlToTextSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridHtmlToTextSpec::setUncommonOptions);
+      prototype.registerHybridMethod("toText", &HybridHtmlToTextSpec::toText);
+      prototype.registerHybridMethod("toTextSb", &HybridHtmlToTextSpec::toTextSb);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,83 @@
+///
+/// HybridHtmlToTextSpec.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 `HtmlToText`
+   * Inherit this class to create instances of `HybridHtmlToTextSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridHtmlToText: public HybridHtmlToTextSpec {
+   * public:
+   *   HybridHtmlToText(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridHtmlToTextSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridHtmlToTextSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridHtmlToTextSpec() 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 getDecodeHtmlEntities() = 0;
+      virtual void setDecodeHtmlEntities(bool decodeHtmlEntities) = 0;
+      virtual double getRightMargin() = 0;
+      virtual void setRightMargin(double rightMargin) = 0;
+      virtual bool getSuppressLinks() = 0;
+      virtual void setSuppressLinks(bool suppressLinks) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+
+    public:
+      // Methods
+      virtual std::string toText(const std::string& html) = 0;
+      virtual void toTextSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "HtmlToText";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,49 @@
+///
+/// HybridHtmlToXmlSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridHtmlToXmlSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridHtmlToXmlSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridHtmlToXmlSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridHtmlToXmlSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridHtmlToXmlSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridHtmlToXmlSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridHtmlToXmlSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridHtmlToXmlSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridHtmlToXmlSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridHtmlToXmlSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridHtmlToXmlSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridHtmlToXmlSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("dropCustomTags", &HybridHtmlToXmlSpec::getDropCustomTags);
+      prototype.registerHybridSetter("dropCustomTags", &HybridHtmlToXmlSpec::setDropCustomTags);
+      prototype.registerHybridGetter("html", &HybridHtmlToXmlSpec::getHtml);
+      prototype.registerHybridSetter("html", &HybridHtmlToXmlSpec::setHtml);
+      prototype.registerHybridGetter("nbsp", &HybridHtmlToXmlSpec::getNbsp);
+      prototype.registerHybridSetter("nbsp", &HybridHtmlToXmlSpec::setNbsp);
+      prototype.registerHybridGetter("xmlCharset", &HybridHtmlToXmlSpec::getXmlCharset);
+      prototype.registerHybridSetter("xmlCharset", &HybridHtmlToXmlSpec::setXmlCharset);
+      prototype.registerHybridMethod("convertFile", &HybridHtmlToXmlSpec::convertFile);
+      prototype.registerHybridMethod("dropTagType", &HybridHtmlToXmlSpec::dropTagType);
+      prototype.registerHybridMethod("dropTextFormattingTags", &HybridHtmlToXmlSpec::dropTextFormattingTags);
+      prototype.registerHybridMethod("setHtmlFromFile", &HybridHtmlToXmlSpec::setHtmlFromFile);
+      prototype.registerHybridMethod("toXml", &HybridHtmlToXmlSpec::toXml);
+      prototype.registerHybridMethod("undropTagType", &HybridHtmlToXmlSpec::undropTagType);
+      prototype.registerHybridMethod("undropTextFormattingTags", &HybridHtmlToXmlSpec::undropTextFormattingTags);
+      prototype.registerHybridMethod("xml", &HybridHtmlToXmlSpec::xml);
+      prototype.registerHybridMethod("setHtmlBd", &HybridHtmlToXmlSpec::setHtmlBd);
+      prototype.registerHybridMethod("toXmlSb", &HybridHtmlToXmlSpec::toXmlSb);
+      prototype.registerHybridMethod("setHtmlSb", &HybridHtmlToXmlSpec::setHtmlSb);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,95 @@
+///
+/// HybridHtmlToXmlSpec.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; }
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridBinDataSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `HtmlToXml`
+   * Inherit this class to create instances of `HybridHtmlToXmlSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridHtmlToXml: public HybridHtmlToXmlSpec {
+   * public:
+   *   HybridHtmlToXml(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridHtmlToXmlSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridHtmlToXmlSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridHtmlToXmlSpec() 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 getDropCustomTags() = 0;
+      virtual void setDropCustomTags(bool dropCustomTags) = 0;
+      virtual std::string getHtml() = 0;
+      virtual void setHtml(const std::string& html) = 0;
+      virtual double getNbsp() = 0;
+      virtual void setNbsp(double nbsp) = 0;
+      virtual std::string getXmlCharset() = 0;
+      virtual void setXmlCharset(const std::string& xmlCharset) = 0;
+
+    public:
+      // Methods
+      virtual void convertFile(const std::string& inHtmlPath, const std::string& destXmlPath) = 0;
+      virtual void dropTagType(const std::string& tagName) = 0;
+      virtual void dropTextFormattingTags() = 0;
+      virtual void setHtmlFromFile(const std::string& filename) = 0;
+      virtual std::string toXml() = 0;
+      virtual void undropTagType(const std::string& tagName) = 0;
+      virtual void undropTextFormattingTags() = 0;
+      virtual std::string xml() = 0;
+      virtual void setHtmlBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void toXmlSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void setHtmlSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "HtmlToXml";
+  };
+
+} // namespace margelo::nitro::chilkat