@chilkat/react-native 11.6.1

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

@@ -0,0 +1,116 @@
+///
+/// HybridCsrSpec.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 `HybridPrivateKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPrivateKeySpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridPublicKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPublicKeySpec; }
+// Forward declaration of `HybridStringTableSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringTableSpec; }
+// Forward declaration of `HybridXmlSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridXmlSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridPrivateKeySpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridPublicKeySpec.hpp"
+#include "HybridStringTableSpec.hpp"
+#include "HybridXmlSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Csr`
+   * Inherit this class to create instances of `HybridCsrSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCsr: public HybridCsrSpec {
+   * public:
+   *   HybridCsr(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCsrSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCsrSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCsrSpec() 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 getCommonName() = 0;
+      virtual void setCommonName(const std::string& commonName) = 0;
+      virtual std::string getCountry() = 0;
+      virtual void setCountry(const std::string& country) = 0;
+      virtual std::string getState() = 0;
+      virtual void setState(const std::string& state) = 0;
+      virtual std::string getLocality() = 0;
+      virtual void setLocality(const std::string& locality) = 0;
+      virtual std::string getCompany() = 0;
+      virtual void setCompany(const std::string& company) = 0;
+      virtual std::string getCompanyDivision() = 0;
+      virtual void setCompanyDivision(const std::string& companyDivision) = 0;
+      virtual std::string getEmailAddress() = 0;
+      virtual void setEmailAddress(const std::string& emailAddress) = 0;
+      virtual std::string getHashAlgorithm() = 0;
+      virtual void setHashAlgorithm(const std::string& hashAlgorithm) = 0;
+      virtual bool getPssPadding() = 0;
+      virtual void setPssPadding(bool pssPadding) = 0;
+      virtual std::string getMgfHashAlg() = 0;
+      virtual void setMgfHashAlg(const std::string& mgfHashAlg) = 0;
+
+    public:
+      // Methods
+      virtual std::string genCsrPem(const std::shared_ptr<HybridPrivateKeySpec>& privKey) = 0;
+      virtual void genCsrBd(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridBinDataSpec>& csrData) = 0;
+      virtual void setSubjectField(const std::string& oid, const std::string& value, const std::string& asnType) = 0;
+      virtual void loadCsrPem(const std::string& csrPemStr) = 0;
+      virtual std::string getSubjectField(const std::string& oid) = 0;
+      virtual void getPublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubkey) = 0;
+      virtual void verifyCsr() = 0;
+      virtual void addSan(const std::string& sanType, const std::string& sanValue) = 0;
+      virtual void getSans(const std::shared_ptr<HybridStringTableSpec>& sans) = 0;
+      virtual void setExtensionRequest(const std::shared_ptr<HybridXmlSpec>& extensionReqXml) = 0;
+      virtual void getExtensionRequest(const std::shared_ptr<HybridXmlSpec>& extensionReqXml) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Csr";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,72 @@
+///
+/// HybridCsvSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridCsvSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridCsvSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridCsvSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridCsvSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridCsvSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridCsvSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridCsvSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridCsvSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridCsvSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridCsvSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridCsvSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridCsvSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("autoTrim", &HybridCsvSpec::getAutoTrim);
+      prototype.registerHybridSetter("autoTrim", &HybridCsvSpec::setAutoTrim);
+      prototype.registerHybridGetter("crlf", &HybridCsvSpec::getCrlf);
+      prototype.registerHybridSetter("crlf", &HybridCsvSpec::setCrlf);
+      prototype.registerHybridGetter("delimiter", &HybridCsvSpec::getDelimiter);
+      prototype.registerHybridSetter("delimiter", &HybridCsvSpec::setDelimiter);
+      prototype.registerHybridGetter("escapeBackslash", &HybridCsvSpec::getEscapeBackslash);
+      prototype.registerHybridSetter("escapeBackslash", &HybridCsvSpec::setEscapeBackslash);
+      prototype.registerHybridGetter("hasColumnNames", &HybridCsvSpec::getHasColumnNames);
+      prototype.registerHybridSetter("hasColumnNames", &HybridCsvSpec::setHasColumnNames);
+      prototype.registerHybridGetter("numColumns", &HybridCsvSpec::getNumColumns);
+      prototype.registerHybridGetter("numRows", &HybridCsvSpec::getNumRows);
+      prototype.registerHybridGetter("enableQuotes", &HybridCsvSpec::getEnableQuotes);
+      prototype.registerHybridSetter("enableQuotes", &HybridCsvSpec::setEnableQuotes);
+      prototype.registerHybridGetter("uncommonOptions", &HybridCsvSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridCsvSpec::setUncommonOptions);
+      prototype.registerHybridGetter("xlsxDateFormat", &HybridCsvSpec::getXlsxDateFormat);
+      prototype.registerHybridSetter("xlsxDateFormat", &HybridCsvSpec::setXlsxDateFormat);
+      prototype.registerHybridMethod("deleteColumn", &HybridCsvSpec::deleteColumn);
+      prototype.registerHybridMethod("deleteColumnByName", &HybridCsvSpec::deleteColumnByName);
+      prototype.registerHybridMethod("deleteRow", &HybridCsvSpec::deleteRow);
+      prototype.registerHybridMethod("getCell", &HybridCsvSpec::getCell);
+      prototype.registerHybridMethod("getCellByName", &HybridCsvSpec::getCellByName);
+      prototype.registerHybridMethod("getColumnName", &HybridCsvSpec::getColumnName);
+      prototype.registerHybridMethod("getIndex", &HybridCsvSpec::getIndex);
+      prototype.registerHybridMethod("getNumCols", &HybridCsvSpec::getNumCols);
+      prototype.registerHybridMethod("loadFile", &HybridCsvSpec::loadFile);
+      prototype.registerHybridMethod("loadFile2", &HybridCsvSpec::loadFile2);
+      prototype.registerHybridMethod("loadFromString", &HybridCsvSpec::loadFromString);
+      prototype.registerHybridMethod("rowMatches", &HybridCsvSpec::rowMatches);
+      prototype.registerHybridMethod("saveFile", &HybridCsvSpec::saveFile);
+      prototype.registerHybridMethod("saveFile2", &HybridCsvSpec::saveFile2);
+      prototype.registerHybridMethod("saveToString", &HybridCsvSpec::saveToString);
+      prototype.registerHybridMethod("setCell", &HybridCsvSpec::setCell);
+      prototype.registerHybridMethod("setCellByName", &HybridCsvSpec::setCellByName);
+      prototype.registerHybridMethod("setColumnName", &HybridCsvSpec::setColumnName);
+      prototype.registerHybridMethod("sortByColumn", &HybridCsvSpec::sortByColumn);
+      prototype.registerHybridMethod("sortByColumnIndex", &HybridCsvSpec::sortByColumnIndex);
+      prototype.registerHybridMethod("insertColumn", &HybridCsvSpec::insertColumn);
+      prototype.registerHybridMethod("saveToSb", &HybridCsvSpec::saveToSb);
+      prototype.registerHybridMethod("xlsxGetSheets", &HybridCsvSpec::xlsxGetSheets);
+      prototype.registerHybridMethod("xlsxLoadSheet", &HybridCsvSpec::xlsxLoadSheet);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,121 @@
+///
+/// HybridCsvSpec.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 `HybridZipSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridZipSpec; }
+// Forward declaration of `HybridStringTableSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringTableSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridZipSpec.hpp"
+#include "HybridStringTableSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Csv`
+   * Inherit this class to create instances of `HybridCsvSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridCsv: public HybridCsvSpec {
+   * public:
+   *   HybridCsv(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridCsvSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridCsvSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridCsvSpec() 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 getAutoTrim() = 0;
+      virtual void setAutoTrim(bool autoTrim) = 0;
+      virtual bool getCrlf() = 0;
+      virtual void setCrlf(bool crlf) = 0;
+      virtual std::string getDelimiter() = 0;
+      virtual void setDelimiter(const std::string& delimiter) = 0;
+      virtual bool getEscapeBackslash() = 0;
+      virtual void setEscapeBackslash(bool escapeBackslash) = 0;
+      virtual bool getHasColumnNames() = 0;
+      virtual void setHasColumnNames(bool hasColumnNames) = 0;
+      virtual double getNumColumns() = 0;
+      virtual double getNumRows() = 0;
+      virtual bool getEnableQuotes() = 0;
+      virtual void setEnableQuotes(bool enableQuotes) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual std::string getXlsxDateFormat() = 0;
+      virtual void setXlsxDateFormat(const std::string& xlsxDateFormat) = 0;
+
+    public:
+      // Methods
+      virtual void deleteColumn(double index) = 0;
+      virtual void deleteColumnByName(const std::string& columnName) = 0;
+      virtual void deleteRow(double index) = 0;
+      virtual std::string getCell(double row, double col) = 0;
+      virtual std::string getCellByName(double rowIndex, const std::string& columnName) = 0;
+      virtual std::string getColumnName(double index) = 0;
+      virtual double getIndex(const std::string& columnName) = 0;
+      virtual double getNumCols(double row) = 0;
+      virtual void loadFile(const std::string& path) = 0;
+      virtual void loadFile2(const std::string& filename, const std::string& charset) = 0;
+      virtual void loadFromString(const std::string& csvData) = 0;
+      virtual bool rowMatches(double rowIndex, const std::string& matchPattern, bool caseSensitive) = 0;
+      virtual void saveFile(const std::string& path) = 0;
+      virtual void saveFile2(const std::string& filename, const std::string& charset) = 0;
+      virtual std::string saveToString() = 0;
+      virtual void setCell(double row, double col, const std::string& content) = 0;
+      virtual void setCellByName(double rowIndex, const std::string& columnName, const std::string& contentStr) = 0;
+      virtual void setColumnName(double index, const std::string& columnName) = 0;
+      virtual void sortByColumn(const std::string& columnName, bool ascending, bool caseSensitive) = 0;
+      virtual void sortByColumnIndex(double index, bool ascending, bool caseSensitive) = 0;
+      virtual void insertColumn(double index) = 0;
+      virtual void saveToSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void xlsxGetSheets(const std::shared_ptr<HybridZipSpec>& xlsx, const std::shared_ptr<HybridStringTableSpec>& sheetNames) = 0;
+      virtual void xlsxLoadSheet(const std::shared_ptr<HybridZipSpec>& zip, const std::string& sheetName) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Csv";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,37 @@
+///
+/// HybridDhSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridDhSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridDhSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridDhSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridDhSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridDhSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridDhSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridDhSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridDhSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridDhSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridDhSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridDhSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridDhSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("g", &HybridDhSpec::getG);
+      prototype.registerHybridGetter("p", &HybridDhSpec::getP);
+      prototype.registerHybridMethod("createE", &HybridDhSpec::createE);
+      prototype.registerHybridMethod("findK", &HybridDhSpec::findK);
+      prototype.registerHybridMethod("genPG", &HybridDhSpec::genPG);
+      prototype.registerHybridMethod("setPG", &HybridDhSpec::setPG);
+      prototype.registerHybridMethod("useKnownPrime", &HybridDhSpec::useKnownPrime);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,77 @@
+///
+/// HybridDhSpec.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
+
+
+
+#include <string>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Dh`
+   * Inherit this class to create instances of `HybridDhSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridDh: public HybridDhSpec {
+   * public:
+   *   HybridDh(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridDhSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridDhSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridDhSpec() 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 getG() = 0;
+      virtual std::string getP() = 0;
+
+    public:
+      // Methods
+      virtual std::string createE(double numBits) = 0;
+      virtual std::string findK(const std::string& e) = 0;
+      virtual void genPG(double numBits, double g) = 0;
+      virtual void setPG(const std::string& p, double g) = 0;
+      virtual void useKnownPrime(double index) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Dh";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,46 @@
+///
+/// HybridDirTreeSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridDirTreeSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridDirTreeSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridDirTreeSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridDirTreeSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridDirTreeSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridDirTreeSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridDirTreeSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridDirTreeSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridDirTreeSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridDirTreeSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridDirTreeSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridDirTreeSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("baseDir", &HybridDirTreeSpec::getBaseDir);
+      prototype.registerHybridSetter("baseDir", &HybridDirTreeSpec::setBaseDir);
+      prototype.registerHybridGetter("doneIterating", &HybridDirTreeSpec::getDoneIterating);
+      prototype.registerHybridGetter("fileSize32", &HybridDirTreeSpec::getFileSize32);
+      prototype.registerHybridGetter("fileSize64", &HybridDirTreeSpec::getFileSize64);
+      prototype.registerHybridGetter("fullPath", &HybridDirTreeSpec::getFullPath);
+      prototype.registerHybridGetter("fullUncPath", &HybridDirTreeSpec::getFullUncPath);
+      prototype.registerHybridGetter("isDirectory", &HybridDirTreeSpec::getIsDirectory);
+      prototype.registerHybridGetter("recurse", &HybridDirTreeSpec::getRecurse);
+      prototype.registerHybridSetter("recurse", &HybridDirTreeSpec::setRecurse);
+      prototype.registerHybridGetter("relativePath", &HybridDirTreeSpec::getRelativePath);
+      prototype.registerHybridGetter("fileSizeStr", &HybridDirTreeSpec::getFileSizeStr);
+      prototype.registerHybridGetter("uncommonOptions", &HybridDirTreeSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridDirTreeSpec::setUncommonOptions);
+      prototype.registerHybridMethod("advancePosition", &HybridDirTreeSpec::advancePosition);
+      prototype.registerHybridMethod("beginIterate", &HybridDirTreeSpec::beginIterate);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,86 @@
+///
+/// HybridDirTreeSpec.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
+
+
+
+#include <string>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `DirTree`
+   * Inherit this class to create instances of `HybridDirTreeSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridDirTree: public HybridDirTreeSpec {
+   * public:
+   *   HybridDirTree(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridDirTreeSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridDirTreeSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridDirTreeSpec() 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 getBaseDir() = 0;
+      virtual void setBaseDir(const std::string& baseDir) = 0;
+      virtual bool getDoneIterating() = 0;
+      virtual double getFileSize32() = 0;
+      virtual double getFileSize64() = 0;
+      virtual std::string getFullPath() = 0;
+      virtual std::string getFullUncPath() = 0;
+      virtual bool getIsDirectory() = 0;
+      virtual bool getRecurse() = 0;
+      virtual void setRecurse(bool recurse) = 0;
+      virtual std::string getRelativePath() = 0;
+      virtual std::string getFileSizeStr() = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+
+    public:
+      // Methods
+      virtual void advancePosition() = 0;
+      virtual void beginIterate() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "DirTree";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,60 @@
+///
+/// HybridDkimSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridDkimSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridDkimSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridDkimSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridDkimSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridDkimSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridDkimSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridDkimSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridDkimSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridDkimSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridDkimSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridDkimSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridDkimSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("dkimAlg", &HybridDkimSpec::getDkimAlg);
+      prototype.registerHybridSetter("dkimAlg", &HybridDkimSpec::setDkimAlg);
+      prototype.registerHybridGetter("dkimBodyLengthCount", &HybridDkimSpec::getDkimBodyLengthCount);
+      prototype.registerHybridSetter("dkimBodyLengthCount", &HybridDkimSpec::setDkimBodyLengthCount);
+      prototype.registerHybridGetter("dkimCanon", &HybridDkimSpec::getDkimCanon);
+      prototype.registerHybridSetter("dkimCanon", &HybridDkimSpec::setDkimCanon);
+      prototype.registerHybridGetter("dkimDomain", &HybridDkimSpec::getDkimDomain);
+      prototype.registerHybridSetter("dkimDomain", &HybridDkimSpec::setDkimDomain);
+      prototype.registerHybridGetter("dkimHeaders", &HybridDkimSpec::getDkimHeaders);
+      prototype.registerHybridSetter("dkimHeaders", &HybridDkimSpec::setDkimHeaders);
+      prototype.registerHybridGetter("dkimSelector", &HybridDkimSpec::getDkimSelector);
+      prototype.registerHybridSetter("dkimSelector", &HybridDkimSpec::setDkimSelector);
+      prototype.registerHybridGetter("heartbeatMs", &HybridDkimSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridDkimSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("abortCurrent", &HybridDkimSpec::getAbortCurrent);
+      prototype.registerHybridSetter("abortCurrent", &HybridDkimSpec::setAbortCurrent);
+      prototype.registerHybridGetter("verifyInfo", &HybridDkimSpec::getVerifyInfo);
+      prototype.registerHybridGetter("onPercentDone", &HybridDkimSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridDkimSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridDkimSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridDkimSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("loadPublicKey", &HybridDkimSpec::loadPublicKey);
+      prototype.registerHybridMethod("loadPublicKeyFile", &HybridDkimSpec::loadPublicKeyFile);
+      prototype.registerHybridMethod("prefetchPublicKey", &HybridDkimSpec::prefetchPublicKey);
+      prototype.registerHybridMethod("prefetchPublicKeyAsync", &HybridDkimSpec::prefetchPublicKeyAsync);
+      prototype.registerHybridMethod("dkimSign", &HybridDkimSpec::dkimSign);
+      prototype.registerHybridMethod("setDkimPrivateKey", &HybridDkimSpec::setDkimPrivateKey);
+      prototype.registerHybridMethod("dkimVerify", &HybridDkimSpec::dkimVerify);
+      prototype.registerHybridMethod("numDkimSigs", &HybridDkimSpec::numDkimSigs);
+      prototype.registerHybridMethod("abort", &HybridDkimSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat