@chilkat/react-native 11.6.1

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

@@ -0,0 +1,253 @@
+///
+/// HybridXmlSpec.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 `HybridXmlSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridXmlSpec; }
+// 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; }
+
+#include <string>
+#include <memory>
+#include "HybridXmlSpec.hpp"
+#include <optional>
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Xml`
+   * Inherit this class to create instances of `HybridXmlSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridXml: public HybridXmlSpec {
+   * public:
+   *   HybridXml(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridXmlSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridXmlSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridXmlSpec() 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 getCdata() = 0;
+      virtual void setCdata(bool cdata) = 0;
+      virtual std::string getContent() = 0;
+      virtual void setContent(const std::string& content) = 0;
+      virtual double getContentInt() = 0;
+      virtual void setContentInt(double contentInt) = 0;
+      virtual std::string getDocType() = 0;
+      virtual void setDocType(const std::string& docType) = 0;
+      virtual bool getEmitBom() = 0;
+      virtual void setEmitBom(bool emitBom) = 0;
+      virtual bool getEmitXmlDecl() = 0;
+      virtual void setEmitXmlDecl(bool emitXmlDecl) = 0;
+      virtual std::string getEncoding() = 0;
+      virtual void setEncoding(const std::string& encoding) = 0;
+      virtual double getNumAttributes() = 0;
+      virtual double getNumChildren() = 0;
+      virtual bool getSortCaseInsensitive() = 0;
+      virtual void setSortCaseInsensitive(bool sortCaseInsensitive) = 0;
+      virtual bool getStandalone() = 0;
+      virtual void setStandalone(bool standalone) = 0;
+      virtual bool getStrict() = 0;
+      virtual void setStrict(bool strict) = 0;
+      virtual std::string getTag() = 0;
+      virtual void setTag(const std::string& tag) = 0;
+      virtual double getTreeId() = 0;
+      virtual double getI() = 0;
+      virtual void setI(double i) = 0;
+      virtual double getJ() = 0;
+      virtual void setJ(double j) = 0;
+      virtual double getK() = 0;
+      virtual void setK(double k) = 0;
+      virtual bool getEmitCompact() = 0;
+      virtual void setEmitCompact(bool emitCompact) = 0;
+      virtual bool getIsBase64() = 0;
+      virtual std::string getTagNsPrefix() = 0;
+      virtual void setTagNsPrefix(const std::string& tagNsPrefix) = 0;
+      virtual std::string getTagUnprefixed() = 0;
+      virtual void setTagUnprefixed(const std::string& tagUnprefixed) = 0;
+      virtual std::string getTagPath() = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+
+    public:
+      // Methods
+      virtual std::string accumulateTagContent(const std::string& tag, const std::string& skipTags) = 0;
+      virtual void addAttribute(const std::string& name, const std::string& value) = 0;
+      virtual void addAttributeInt(const std::string& name, double value) = 0;
+      virtual void addChildTree(const std::shared_ptr<HybridXmlSpec>& tree) = 0;
+      virtual void addOrUpdateAttribute(const std::string& name, const std::string& value) = 0;
+      virtual void addOrUpdateAttributeI(const std::string& name, double value) = 0;
+      virtual void addStyleSheet(const std::string& styleSheet) = 0;
+      virtual void addToAttribute(const std::string& name, double amount) = 0;
+      virtual void addToChildContent(const std::string& tag, double amount) = 0;
+      virtual void addToContent(double amount) = 0;
+      virtual void appendToContent(const std::string& str) = 0;
+      virtual bool childContentMatches(const std::string& tagPath, const std::string& pattern, bool caseSensitive) = 0;
+      virtual std::string chilkatPath(const std::string& pathCmd) = 0;
+      virtual void clear() = 0;
+      virtual bool contentMatches(const std::string& pattern, bool caseSensitive) = 0;
+      virtual void copy(const std::shared_ptr<HybridXmlSpec>& node) = 0;
+      virtual void copyRef(const std::shared_ptr<HybridXmlSpec>& copyFromNode) = 0;
+      virtual std::string decodeEntities(const std::string& str) = 0;
+      virtual void decryptContent(const std::string& password) = 0;
+      virtual void encryptContent(const std::string& password) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> extractChildByIndex(double index) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> extractChildByName(const std::string& tagPath, const std::string& attrName, const std::string& attrValue) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> findChild(const std::string& tagPath) = 0;
+      virtual void findChild2(const std::string& tagPath) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> findNextRecord(const std::string& tagPath, const std::string& contentPattern) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> findOrAddNewChild(const std::string& tagPath) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> firstChild() = 0;
+      virtual bool firstChild2() = 0;
+      virtual std::string getAttrValue(const std::string& name) = 0;
+      virtual double getAttrValueInt(const std::string& name) = 0;
+      virtual std::string getAttributeName(double index) = 0;
+      virtual std::string getAttributeValue(double index) = 0;
+      virtual double getAttributeValueInt(double index) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> getChild(double index) = 0;
+      virtual void getChild2(double index) = 0;
+      virtual bool getChildBoolValue(const std::string& tagPath) = 0;
+      virtual std::string getChildContent(const std::string& tagPath) = 0;
+      virtual std::string getChildContentByIndex(double index) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> getChildExact(const std::string& tag, const std::string& content) = 0;
+      virtual double getChildIntValue(const std::string& tagPath) = 0;
+      virtual std::string getChildTag(double index) = 0;
+      virtual std::string getChildTagByIndex(double index) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> getChildWithAttr(const std::string& tagPath, const std::string& attrName, const std::string& attrValue) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> getChildWithContent(const std::string& content) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> getChildWithTag(const std::string& tagPath) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> getNthChildWithTag(const std::string& tag, double n) = 0;
+      virtual void getNthChildWithTag2(const std::string& tag, double n) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> getParent() = 0;
+      virtual void getParent2() = 0;
+      virtual std::shared_ptr<HybridXmlSpec> getRoot() = 0;
+      virtual void getRoot2() = 0;
+      virtual std::shared_ptr<HybridXmlSpec> getSelf() = 0;
+      virtual std::string getXml() = 0;
+      virtual bool hasAttrWithValue(const std::string& name, const std::string& value) = 0;
+      virtual bool hasAttribute(const std::string& name) = 0;
+      virtual bool hasChildWithContent(const std::string& content) = 0;
+      virtual bool hasChildWithTag(const std::string& tagPath) = 0;
+      virtual bool hasChildWithTagAndContent(const std::string& tagPath, const std::string& content) = 0;
+      virtual void insertChildTreeAfter(double index, const std::shared_ptr<HybridXmlSpec>& tree) = 0;
+      virtual void insertChildTreeBefore(double index, const std::shared_ptr<HybridXmlSpec>& tree) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> lastChild() = 0;
+      virtual void lastChild2() = 0;
+      virtual void loadXml(const std::string& xmlData) = 0;
+      virtual void loadXml2(const std::string& xmlData, bool autoTrim) = 0;
+      virtual void loadXmlFile(const std::string& fileName) = 0;
+      virtual void loadXmlFile2(const std::string& fileName, bool autoTrim) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> newChild(const std::string& tagPath, const std::string& content) = 0;
+      virtual void newChild2(const std::string& tagPath, const std::string& content) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> newChildAfter(double index, const std::string& tag, const std::string& content) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> newChildBefore(double index, const std::string& tag, const std::string& content) = 0;
+      virtual void newChildInt2(const std::string& tagPath, double value) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> nextSibling() = 0;
+      virtual bool nextSibling2() = 0;
+      virtual double numChildrenHavingTag(const std::string& tag) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> previousSibling() = 0;
+      virtual void previousSibling2() = 0;
+      virtual void removeAllAttributes() = 0;
+      virtual void removeAllChildren() = 0;
+      virtual void removeAttribute(const std::string& name) = 0;
+      virtual void removeChild(const std::string& tagPath) = 0;
+      virtual void removeChildByIndex(double index) = 0;
+      virtual void removeChildWithContent(const std::string& content) = 0;
+      virtual void removeFromTree() = 0;
+      virtual void saveBinaryContent(const std::string& filename, bool unzipFlag, bool decryptFlag, const std::string& password) = 0;
+      virtual void saveXml(const std::string& fileName) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> searchAllForContent(const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) = 0;
+      virtual void searchAllForContent2(const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> searchForAttribute(const std::string& tag, const std::string& attr, const std::string& valuePattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) = 0;
+      virtual void searchForAttribute2(const std::string& tag, const std::string& attr, const std::string& valuePattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> searchForContent(const std::string& tag, const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) = 0;
+      virtual void searchForContent2(const std::string& tag, const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> searchForTag(const std::string& tag, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) = 0;
+      virtual void searchForTag2(const std::string& tag, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) = 0;
+      virtual void setBinaryContentFromFile(const std::string& filename, bool zipFlag, bool encryptFlag, const std::string& password) = 0;
+      virtual void sortByAttribute(const std::string& attrName, bool ascending) = 0;
+      virtual void sortByAttributeInt(const std::string& attrName, bool ascending) = 0;
+      virtual void sortByContent(bool ascending) = 0;
+      virtual void sortByTag(bool ascending) = 0;
+      virtual void sortRecordsByAttribute(const std::string& sortTag, const std::string& attrName, bool ascending) = 0;
+      virtual void sortRecordsByContent(const std::string& sortTag, bool ascending) = 0;
+      virtual void sortRecordsByContentInt(const std::string& sortTag, bool ascending) = 0;
+      virtual void swapNode(const std::shared_ptr<HybridXmlSpec>& node) = 0;
+      virtual void swapTree(const std::shared_ptr<HybridXmlSpec>& tree) = 0;
+      virtual std::string tagContent(const std::string& tagName) = 0;
+      virtual bool tagEquals(const std::string& tag) = 0;
+      virtual void unzipContent() = 0;
+      virtual void unzipTree() = 0;
+      virtual void updateAttribute(const std::string& attrName, const std::string& attrValue) = 0;
+      virtual void updateAttributeInt(const std::string& attrName, double value) = 0;
+      virtual void updateChildContent(const std::string& tagPath, const std::string& value) = 0;
+      virtual void updateChildContentInt(const std::string& tagPath, double value) = 0;
+      virtual void zipContent() = 0;
+      virtual void zipTree() = 0;
+      virtual void loadSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool autoTrim) = 0;
+      virtual void getXmlSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual double numChildrenAt(const std::string& tagPath) = 0;
+      virtual void updateAt(const std::string& tagPath, bool autoCreate, const std::string& value) = 0;
+      virtual void updateAttrAt(const std::string& tagPath, bool autoCreate, const std::string& attrName, const std::string& attrValue) = 0;
+      virtual void getChildContentSb(const std::string& tagPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual double tagIndex(const std::string& tagPath) = 0;
+      virtual bool tagNsEquals(const std::string& ns) = 0;
+      virtual bool tagUnpEquals(const std::string& unprefixedTag) = 0;
+      virtual std::string getChildAttrValue(const std::string& tagPath, const std::string& attrName) = 0;
+      virtual double removeStyleSheet(const std::string& attrName, const std::string& attrValue) = 0;
+      virtual double pruneAttribute(const std::string& attrName) = 0;
+      virtual double pruneTag(const std::string& tag) = 0;
+      virtual void scrub(const std::string& directives) = 0;
+      virtual void loadBd(const std::shared_ptr<HybridBinDataSpec>& bd, bool autoTrim) = 0;
+      virtual void getXmlBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual bool nextInTraversal2(const std::shared_ptr<HybridStringBuilderSpec>& sbState) = 0;
+      virtual void setBinaryContentBd(const std::shared_ptr<HybridBinDataSpec>& data, bool zipFlag, bool encryptFlag, const std::string& password) = 0;
+      virtual void getChildWithTag2(const std::string& tagPath) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Xml";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,58 @@
+///
+/// HybridXmpSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridXmpSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridXmpSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridXmpSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridXmpSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridXmpSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridXmpSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridXmpSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridXmpSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridXmpSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridXmpSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridXmpSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridXmpSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("numEmbedded", &HybridXmpSpec::getNumEmbedded);
+      prototype.registerHybridGetter("structInnerDescrip", &HybridXmpSpec::getStructInnerDescrip);
+      prototype.registerHybridSetter("structInnerDescrip", &HybridXmpSpec::setStructInnerDescrip);
+      prototype.registerHybridGetter("uncommonOptions", &HybridXmpSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridXmpSpec::setUncommonOptions);
+      prototype.registerHybridMethod("addArray", &HybridXmpSpec::addArray);
+      prototype.registerHybridMethod("addNsMapping", &HybridXmpSpec::addNsMapping);
+      prototype.registerHybridMethod("addSimpleInt", &HybridXmpSpec::addSimpleInt);
+      prototype.registerHybridMethod("addSimpleStr", &HybridXmpSpec::addSimpleStr);
+      prototype.registerHybridMethod("addStructProp", &HybridXmpSpec::addStructProp);
+      prototype.registerHybridMethod("append", &HybridXmpSpec::append);
+      prototype.registerHybridMethod("getArray", &HybridXmpSpec::getArray);
+      prototype.registerHybridMethod("getEmbedded", &HybridXmpSpec::getEmbedded);
+      prototype.registerHybridMethod("getProperty", &HybridXmpSpec::getProperty);
+      prototype.registerHybridMethod("getSimpleInt", &HybridXmpSpec::getSimpleInt);
+      prototype.registerHybridMethod("getSimpleStr", &HybridXmpSpec::getSimpleStr);
+      prototype.registerHybridMethod("getStructPropNames", &HybridXmpSpec::getStructPropNames);
+      prototype.registerHybridMethod("getStructValue", &HybridXmpSpec::getStructValue);
+      prototype.registerHybridMethod("loadAppFile", &HybridXmpSpec::loadAppFile);
+      prototype.registerHybridMethod("newXmp", &HybridXmpSpec::newXmp);
+      prototype.registerHybridMethod("removeAllEmbedded", &HybridXmpSpec::removeAllEmbedded);
+      prototype.registerHybridMethod("removeArray", &HybridXmpSpec::removeArray);
+      prototype.registerHybridMethod("removeEmbedded", &HybridXmpSpec::removeEmbedded);
+      prototype.registerHybridMethod("removeNsMapping", &HybridXmpSpec::removeNsMapping);
+      prototype.registerHybridMethod("removeSimple", &HybridXmpSpec::removeSimple);
+      prototype.registerHybridMethod("removeStruct", &HybridXmpSpec::removeStruct);
+      prototype.registerHybridMethod("removeStructProp", &HybridXmpSpec::removeStructProp);
+      prototype.registerHybridMethod("saveAppFile", &HybridXmpSpec::saveAppFile);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,104 @@
+///
+/// HybridXmpSpec.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 `HybridXmlSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridXmlSpec; }
+// Forward declaration of `HybridStringArraySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringArraySpec; }
+
+#include <string>
+#include <memory>
+#include "HybridXmlSpec.hpp"
+#include "HybridStringArraySpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Xmp`
+   * Inherit this class to create instances of `HybridXmpSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridXmp: public HybridXmpSpec {
+   * public:
+   *   HybridXmp(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridXmpSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridXmpSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridXmpSpec() 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 getNumEmbedded() = 0;
+      virtual bool getStructInnerDescrip() = 0;
+      virtual void setStructInnerDescrip(bool structInnerDescrip) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+
+    public:
+      // Methods
+      virtual void addArray(const std::shared_ptr<HybridXmlSpec>& xml, const std::string& arrType, const std::string& propName, const std::shared_ptr<HybridStringArraySpec>& values) = 0;
+      virtual void addNsMapping(const std::string& ns, const std::string& uri) = 0;
+      virtual void addSimpleInt(const std::shared_ptr<HybridXmlSpec>& iXml, const std::string& propName, double propVal) = 0;
+      virtual void addSimpleStr(const std::shared_ptr<HybridXmlSpec>& iXml, const std::string& propName, const std::string& propVal) = 0;
+      virtual void addStructProp(const std::shared_ptr<HybridXmlSpec>& iChilkatXml, const std::string& structName, const std::string& propName, const std::string& propValue) = 0;
+      virtual void append(const std::shared_ptr<HybridXmlSpec>& iXml) = 0;
+      virtual std::shared_ptr<HybridStringArraySpec> getArray(const std::shared_ptr<HybridXmlSpec>& iXml, const std::string& propName) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> getEmbedded(double index) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> getProperty(const std::shared_ptr<HybridXmlSpec>& iXml, const std::string& propName) = 0;
+      virtual double getSimpleInt(const std::shared_ptr<HybridXmlSpec>& iXml, const std::string& propName) = 0;
+      virtual std::string getSimpleStr(const std::shared_ptr<HybridXmlSpec>& iXml, const std::string& propName) = 0;
+      virtual std::shared_ptr<HybridStringArraySpec> getStructPropNames(const std::shared_ptr<HybridXmlSpec>& iXml, const std::string& structName) = 0;
+      virtual std::string getStructValue(const std::shared_ptr<HybridXmlSpec>& iXml, const std::string& structName, const std::string& propName) = 0;
+      virtual void loadAppFile(const std::string& filename) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> newXmp() = 0;
+      virtual void removeAllEmbedded() = 0;
+      virtual void removeArray(const std::shared_ptr<HybridXmlSpec>& iXml, const std::string& propName) = 0;
+      virtual void removeEmbedded(double index) = 0;
+      virtual void removeNsMapping(const std::string& ns) = 0;
+      virtual void removeSimple(const std::shared_ptr<HybridXmlSpec>& iXml, const std::string& propName) = 0;
+      virtual void removeStruct(const std::shared_ptr<HybridXmlSpec>& iXml, const std::string& structName) = 0;
+      virtual void removeStructProp(const std::shared_ptr<HybridXmlSpec>& iXml, const std::string& structName, const std::string& propName) = 0;
+      virtual void saveAppFile(const std::string& filename) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Xmp";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,43 @@
+///
+/// HybridZipCrcSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridZipCrcSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridZipCrcSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridZipCrcSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridZipCrcSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridZipCrcSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridZipCrcSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridZipCrcSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridZipCrcSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridZipCrcSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridZipCrcSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridZipCrcSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridZipCrcSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("onPercentDone", &HybridZipCrcSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridZipCrcSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridZipCrcSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridZipCrcSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("beginStream", &HybridZipCrcSpec::beginStream);
+      prototype.registerHybridMethod("endStream", &HybridZipCrcSpec::endStream);
+      prototype.registerHybridMethod("fileCrc", &HybridZipCrcSpec::fileCrc);
+      prototype.registerHybridMethod("fileCrcAsync", &HybridZipCrcSpec::fileCrcAsync);
+      prototype.registerHybridMethod("toHex", &HybridZipCrcSpec::toHex);
+      prototype.registerHybridMethod("crcString", &HybridZipCrcSpec::crcString);
+      prototype.registerHybridMethod("crcSb", &HybridZipCrcSpec::crcSb);
+      prototype.registerHybridMethod("crcBd", &HybridZipCrcSpec::crcBd);
+      prototype.registerHybridMethod("abort", &HybridZipCrcSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,92 @@
+///
+/// HybridZipCrcSpec.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; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `ZipCrc`
+   * Inherit this class to create instances of `HybridZipCrcSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridZipCrc: public HybridZipCrcSpec {
+   * public:
+   *   HybridZipCrc(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridZipCrcSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridZipCrcSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridZipCrcSpec() 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::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 beginStream() = 0;
+      virtual double endStream() = 0;
+      virtual double fileCrc(const std::string& path) = 0;
+      virtual std::shared_ptr<Promise<double>> fileCrcAsync(const std::string& path) = 0;
+      virtual std::string toHex(double crc) = 0;
+      virtual double crcString(const std::string& str, const std::string& charset) = 0;
+      virtual double crcSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) = 0;
+      virtual double crcBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "ZipCrc";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,82 @@
+///
+/// HybridZipEntrySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridZipEntrySpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridZipEntrySpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridZipEntrySpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridZipEntrySpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridZipEntrySpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridZipEntrySpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridZipEntrySpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridZipEntrySpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridZipEntrySpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridZipEntrySpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridZipEntrySpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridZipEntrySpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("comment", &HybridZipEntrySpec::getComment);
+      prototype.registerHybridSetter("comment", &HybridZipEntrySpec::setComment);
+      prototype.registerHybridGetter("compressedLength", &HybridZipEntrySpec::getCompressedLength);
+      prototype.registerHybridGetter("compressedLength64", &HybridZipEntrySpec::getCompressedLength64);
+      prototype.registerHybridGetter("compressedLengthStr", &HybridZipEntrySpec::getCompressedLengthStr);
+      prototype.registerHybridGetter("compressionLevel", &HybridZipEntrySpec::getCompressionLevel);
+      prototype.registerHybridSetter("compressionLevel", &HybridZipEntrySpec::setCompressionLevel);
+      prototype.registerHybridGetter("compressionMethod", &HybridZipEntrySpec::getCompressionMethod);
+      prototype.registerHybridSetter("compressionMethod", &HybridZipEntrySpec::setCompressionMethod);
+      prototype.registerHybridGetter("crc", &HybridZipEntrySpec::getCrc);
+      prototype.registerHybridGetter("entryID", &HybridZipEntrySpec::getEntryID);
+      prototype.registerHybridGetter("entryType", &HybridZipEntrySpec::getEntryType);
+      prototype.registerHybridGetter("fileDateTimeStr", &HybridZipEntrySpec::getFileDateTimeStr);
+      prototype.registerHybridSetter("fileDateTimeStr", &HybridZipEntrySpec::setFileDateTimeStr);
+      prototype.registerHybridGetter("fileName", &HybridZipEntrySpec::getFileName);
+      prototype.registerHybridSetter("fileName", &HybridZipEntrySpec::setFileName);
+      prototype.registerHybridGetter("fileNameHex", &HybridZipEntrySpec::getFileNameHex);
+      prototype.registerHybridGetter("heartbeatMs", &HybridZipEntrySpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridZipEntrySpec::setHeartbeatMs);
+      prototype.registerHybridGetter("isDirectory", &HybridZipEntrySpec::getIsDirectory);
+      prototype.registerHybridGetter("textFlag", &HybridZipEntrySpec::getTextFlag);
+      prototype.registerHybridSetter("textFlag", &HybridZipEntrySpec::setTextFlag);
+      prototype.registerHybridGetter("uncompressedLength", &HybridZipEntrySpec::getUncompressedLength);
+      prototype.registerHybridGetter("uncompressedLength64", &HybridZipEntrySpec::getUncompressedLength64);
+      prototype.registerHybridGetter("uncompressedLengthStr", &HybridZipEntrySpec::getUncompressedLengthStr);
+      prototype.registerHybridGetter("isAesEncrypted", &HybridZipEntrySpec::getIsAesEncrypted);
+      prototype.registerHybridGetter("encryptionKeyLen", &HybridZipEntrySpec::getEncryptionKeyLen);
+      prototype.registerHybridGetter("onPercentDone", &HybridZipEntrySpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridZipEntrySpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridZipEntrySpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridZipEntrySpec::setOnProgressInfo);
+      prototype.registerHybridMethod("appendString", &HybridZipEntrySpec::appendString);
+      prototype.registerHybridMethod("appendStringAsync", &HybridZipEntrySpec::appendStringAsync);
+      prototype.registerHybridMethod("copyToBase64", &HybridZipEntrySpec::copyToBase64);
+      prototype.registerHybridMethod("copyToHex", &HybridZipEntrySpec::copyToHex);
+      prototype.registerHybridMethod("extract", &HybridZipEntrySpec::extract);
+      prototype.registerHybridMethod("extractAsync", &HybridZipEntrySpec::extractAsync);
+      prototype.registerHybridMethod("extractInto", &HybridZipEntrySpec::extractInto);
+      prototype.registerHybridMethod("extractIntoAsync", &HybridZipEntrySpec::extractIntoAsync);
+      prototype.registerHybridMethod("replaceString", &HybridZipEntrySpec::replaceString);
+      prototype.registerHybridMethod("setDt", &HybridZipEntrySpec::setDt);
+      prototype.registerHybridMethod("unzipToString", &HybridZipEntrySpec::unzipToString);
+      prototype.registerHybridMethod("unzipToStringAsync", &HybridZipEntrySpec::unzipToStringAsync);
+      prototype.registerHybridMethod("unzipToStream", &HybridZipEntrySpec::unzipToStream);
+      prototype.registerHybridMethod("unzipToStreamAsync", &HybridZipEntrySpec::unzipToStreamAsync);
+      prototype.registerHybridMethod("unzipToBd", &HybridZipEntrySpec::unzipToBd);
+      prototype.registerHybridMethod("unzipToBdAsync", &HybridZipEntrySpec::unzipToBdAsync);
+      prototype.registerHybridMethod("unzipToSb", &HybridZipEntrySpec::unzipToSb);
+      prototype.registerHybridMethod("unzipToSbAsync", &HybridZipEntrySpec::unzipToSbAsync);
+      prototype.registerHybridMethod("getNextMatch", &HybridZipEntrySpec::getNextMatch);
+      prototype.registerHybridMethod("getNext", &HybridZipEntrySpec::getNext);
+      prototype.registerHybridMethod("abort", &HybridZipEntrySpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat