@chilkat/react-native 11.6.1

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

@@ -0,0 +1,62 @@
+///
+/// HybridXmlDSigSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridXmlDSigSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridXmlDSigSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridXmlDSigSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridXmlDSigSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridXmlDSigSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridXmlDSigSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridXmlDSigSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridXmlDSigSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridXmlDSigSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridXmlDSigSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridXmlDSigSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridXmlDSigSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("numReferences", &HybridXmlDSigSpec::getNumReferences);
+      prototype.registerHybridGetter("numSignatures", &HybridXmlDSigSpec::getNumSignatures);
+      prototype.registerHybridGetter("selector", &HybridXmlDSigSpec::getSelector);
+      prototype.registerHybridSetter("selector", &HybridXmlDSigSpec::setSelector);
+      prototype.registerHybridGetter("ignoreExternalRefs", &HybridXmlDSigSpec::getIgnoreExternalRefs);
+      prototype.registerHybridSetter("ignoreExternalRefs", &HybridXmlDSigSpec::setIgnoreExternalRefs);
+      prototype.registerHybridGetter("refFailReason", &HybridXmlDSigSpec::getRefFailReason);
+      prototype.registerHybridGetter("externalRefDirs", &HybridXmlDSigSpec::getExternalRefDirs);
+      prototype.registerHybridSetter("externalRefDirs", &HybridXmlDSigSpec::setExternalRefDirs);
+      prototype.registerHybridGetter("uncommonOptions", &HybridXmlDSigSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridXmlDSigSpec::setUncommonOptions);
+      prototype.registerHybridMethod("canonicalizeXml", &HybridXmlDSigSpec::canonicalizeXml);
+      prototype.registerHybridMethod("loadSignature", &HybridXmlDSigSpec::loadSignature);
+      prototype.registerHybridMethod("loadSignatureSb", &HybridXmlDSigSpec::loadSignatureSb);
+      prototype.registerHybridMethod("isReferenceExternal", &HybridXmlDSigSpec::isReferenceExternal);
+      prototype.registerHybridMethod("referenceUri", &HybridXmlDSigSpec::referenceUri);
+      prototype.registerHybridMethod("setRefDataSb", &HybridXmlDSigSpec::setRefDataSb);
+      prototype.registerHybridMethod("setRefDataBd", &HybridXmlDSigSpec::setRefDataBd);
+      prototype.registerHybridMethod("setRefDataFile", &HybridXmlDSigSpec::setRefDataFile);
+      prototype.registerHybridMethod("verifyReferenceDigest", &HybridXmlDSigSpec::verifyReferenceDigest);
+      prototype.registerHybridMethod("canonicalizeFragment", &HybridXmlDSigSpec::canonicalizeFragment);
+      prototype.registerHybridMethod("loadSignatureBd", &HybridXmlDSigSpec::loadSignatureBd);
+      prototype.registerHybridMethod("verifySignature", &HybridXmlDSigSpec::verifySignature);
+      prototype.registerHybridMethod("getKeyInfo", &HybridXmlDSigSpec::getKeyInfo);
+      prototype.registerHybridMethod("getPublicKey", &HybridXmlDSigSpec::getPublicKey);
+      prototype.registerHybridMethod("useCertVault", &HybridXmlDSigSpec::useCertVault);
+      prototype.registerHybridMethod("setHmacKey", &HybridXmlDSigSpec::setHmacKey);
+      prototype.registerHybridMethod("setPublicKey", &HybridXmlDSigSpec::setPublicKey);
+      prototype.registerHybridMethod("getCerts", &HybridXmlDSigSpec::getCerts);
+      prototype.registerHybridMethod("hasEncapsulatedTimeStamp", &HybridXmlDSigSpec::hasEncapsulatedTimeStamp);
+      prototype.registerHybridMethod("addEncapsulatedTimeStamp", &HybridXmlDSigSpec::addEncapsulatedTimeStamp);
+      prototype.registerHybridMethod("setHttpObj", &HybridXmlDSigSpec::setHttpObj);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,126 @@
+///
+/// HybridXmlDSigSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridXmlSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridXmlSpec; }
+// Forward declaration of `HybridPublicKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPublicKeySpec; }
+// Forward declaration of `HybridXmlCertVaultSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridXmlCertVaultSpec; }
+// Forward declaration of `HybridStringArraySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringArraySpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+// Forward declaration of `HybridHttpSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridHttpSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridXmlSpec.hpp"
+#include "HybridPublicKeySpec.hpp"
+#include "HybridXmlCertVaultSpec.hpp"
+#include "HybridStringArraySpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+#include "HybridHttpSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `XmlDSig`
+   * Inherit this class to create instances of `HybridXmlDSigSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridXmlDSig: public HybridXmlDSigSpec {
+   * public:
+   *   HybridXmlDSig(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridXmlDSigSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridXmlDSigSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridXmlDSigSpec() 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 getNumReferences() = 0;
+      virtual double getNumSignatures() = 0;
+      virtual double getSelector() = 0;
+      virtual void setSelector(double selector) = 0;
+      virtual bool getIgnoreExternalRefs() = 0;
+      virtual void setIgnoreExternalRefs(bool ignoreExternalRefs) = 0;
+      virtual double getRefFailReason() = 0;
+      virtual std::string getExternalRefDirs() = 0;
+      virtual void setExternalRefDirs(const std::string& externalRefDirs) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+
+    public:
+      // Methods
+      virtual std::string canonicalizeXml(const std::string& xml, const std::string& version, bool withComments) = 0;
+      virtual void loadSignature(const std::string& xmlSig) = 0;
+      virtual void loadSignatureSb(const std::shared_ptr<HybridStringBuilderSpec>& sbXmlSig) = 0;
+      virtual bool isReferenceExternal(double index) = 0;
+      virtual std::string referenceUri(double index) = 0;
+      virtual void setRefDataSb(double index, const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& charset) = 0;
+      virtual void setRefDataBd(double index, const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual void setRefDataFile(double index, const std::string& path) = 0;
+      virtual bool verifyReferenceDigest(double index) = 0;
+      virtual std::string canonicalizeFragment(const std::string& xml, const std::string& fragmentId, const std::string& version, const std::string& prefixList, bool withComments) = 0;
+      virtual void loadSignatureBd(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual void verifySignature(bool verifyReferenceDigests) = 0;
+      virtual std::shared_ptr<HybridXmlSpec> getKeyInfo() = 0;
+      virtual std::shared_ptr<HybridPublicKeySpec> getPublicKey() = 0;
+      virtual void useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& certVault) = 0;
+      virtual void setHmacKey(const std::string& key, const std::string& encoding) = 0;
+      virtual void setPublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubKey) = 0;
+      virtual void getCerts(const std::shared_ptr<HybridStringArraySpec>& sa) = 0;
+      virtual bool hasEncapsulatedTimeStamp() = 0;
+      virtual void addEncapsulatedTimeStamp(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridStringBuilderSpec>& sbOut) = 0;
+      virtual void setHttpObj(const std::shared_ptr<HybridHttpSpec>& http) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "XmlDSig";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,203 @@
+///
+/// HybridXmlSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridXmlSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridXmlSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridXmlSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridXmlSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridXmlSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridXmlSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridXmlSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridXmlSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridXmlSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridXmlSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridXmlSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridXmlSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("cdata", &HybridXmlSpec::getCdata);
+      prototype.registerHybridSetter("cdata", &HybridXmlSpec::setCdata);
+      prototype.registerHybridGetter("content", &HybridXmlSpec::getContent);
+      prototype.registerHybridSetter("content", &HybridXmlSpec::setContent);
+      prototype.registerHybridGetter("contentInt", &HybridXmlSpec::getContentInt);
+      prototype.registerHybridSetter("contentInt", &HybridXmlSpec::setContentInt);
+      prototype.registerHybridGetter("docType", &HybridXmlSpec::getDocType);
+      prototype.registerHybridSetter("docType", &HybridXmlSpec::setDocType);
+      prototype.registerHybridGetter("emitBom", &HybridXmlSpec::getEmitBom);
+      prototype.registerHybridSetter("emitBom", &HybridXmlSpec::setEmitBom);
+      prototype.registerHybridGetter("emitXmlDecl", &HybridXmlSpec::getEmitXmlDecl);
+      prototype.registerHybridSetter("emitXmlDecl", &HybridXmlSpec::setEmitXmlDecl);
+      prototype.registerHybridGetter("encoding", &HybridXmlSpec::getEncoding);
+      prototype.registerHybridSetter("encoding", &HybridXmlSpec::setEncoding);
+      prototype.registerHybridGetter("numAttributes", &HybridXmlSpec::getNumAttributes);
+      prototype.registerHybridGetter("numChildren", &HybridXmlSpec::getNumChildren);
+      prototype.registerHybridGetter("sortCaseInsensitive", &HybridXmlSpec::getSortCaseInsensitive);
+      prototype.registerHybridSetter("sortCaseInsensitive", &HybridXmlSpec::setSortCaseInsensitive);
+      prototype.registerHybridGetter("standalone", &HybridXmlSpec::getStandalone);
+      prototype.registerHybridSetter("standalone", &HybridXmlSpec::setStandalone);
+      prototype.registerHybridGetter("strict", &HybridXmlSpec::getStrict);
+      prototype.registerHybridSetter("strict", &HybridXmlSpec::setStrict);
+      prototype.registerHybridGetter("tag", &HybridXmlSpec::getTag);
+      prototype.registerHybridSetter("tag", &HybridXmlSpec::setTag);
+      prototype.registerHybridGetter("treeId", &HybridXmlSpec::getTreeId);
+      prototype.registerHybridGetter("i", &HybridXmlSpec::getI);
+      prototype.registerHybridSetter("i", &HybridXmlSpec::setI);
+      prototype.registerHybridGetter("j", &HybridXmlSpec::getJ);
+      prototype.registerHybridSetter("j", &HybridXmlSpec::setJ);
+      prototype.registerHybridGetter("k", &HybridXmlSpec::getK);
+      prototype.registerHybridSetter("k", &HybridXmlSpec::setK);
+      prototype.registerHybridGetter("emitCompact", &HybridXmlSpec::getEmitCompact);
+      prototype.registerHybridSetter("emitCompact", &HybridXmlSpec::setEmitCompact);
+      prototype.registerHybridGetter("isBase64", &HybridXmlSpec::getIsBase64);
+      prototype.registerHybridGetter("tagNsPrefix", &HybridXmlSpec::getTagNsPrefix);
+      prototype.registerHybridSetter("tagNsPrefix", &HybridXmlSpec::setTagNsPrefix);
+      prototype.registerHybridGetter("tagUnprefixed", &HybridXmlSpec::getTagUnprefixed);
+      prototype.registerHybridSetter("tagUnprefixed", &HybridXmlSpec::setTagUnprefixed);
+      prototype.registerHybridGetter("tagPath", &HybridXmlSpec::getTagPath);
+      prototype.registerHybridGetter("uncommonOptions", &HybridXmlSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridXmlSpec::setUncommonOptions);
+      prototype.registerHybridMethod("accumulateTagContent", &HybridXmlSpec::accumulateTagContent);
+      prototype.registerHybridMethod("addAttribute", &HybridXmlSpec::addAttribute);
+      prototype.registerHybridMethod("addAttributeInt", &HybridXmlSpec::addAttributeInt);
+      prototype.registerHybridMethod("addChildTree", &HybridXmlSpec::addChildTree);
+      prototype.registerHybridMethod("addOrUpdateAttribute", &HybridXmlSpec::addOrUpdateAttribute);
+      prototype.registerHybridMethod("addOrUpdateAttributeI", &HybridXmlSpec::addOrUpdateAttributeI);
+      prototype.registerHybridMethod("addStyleSheet", &HybridXmlSpec::addStyleSheet);
+      prototype.registerHybridMethod("addToAttribute", &HybridXmlSpec::addToAttribute);
+      prototype.registerHybridMethod("addToChildContent", &HybridXmlSpec::addToChildContent);
+      prototype.registerHybridMethod("addToContent", &HybridXmlSpec::addToContent);
+      prototype.registerHybridMethod("appendToContent", &HybridXmlSpec::appendToContent);
+      prototype.registerHybridMethod("childContentMatches", &HybridXmlSpec::childContentMatches);
+      prototype.registerHybridMethod("chilkatPath", &HybridXmlSpec::chilkatPath);
+      prototype.registerHybridMethod("clear", &HybridXmlSpec::clear);
+      prototype.registerHybridMethod("contentMatches", &HybridXmlSpec::contentMatches);
+      prototype.registerHybridMethod("copy", &HybridXmlSpec::copy);
+      prototype.registerHybridMethod("copyRef", &HybridXmlSpec::copyRef);
+      prototype.registerHybridMethod("decodeEntities", &HybridXmlSpec::decodeEntities);
+      prototype.registerHybridMethod("decryptContent", &HybridXmlSpec::decryptContent);
+      prototype.registerHybridMethod("encryptContent", &HybridXmlSpec::encryptContent);
+      prototype.registerHybridMethod("extractChildByIndex", &HybridXmlSpec::extractChildByIndex);
+      prototype.registerHybridMethod("extractChildByName", &HybridXmlSpec::extractChildByName);
+      prototype.registerHybridMethod("findChild", &HybridXmlSpec::findChild);
+      prototype.registerHybridMethod("findChild2", &HybridXmlSpec::findChild2);
+      prototype.registerHybridMethod("findNextRecord", &HybridXmlSpec::findNextRecord);
+      prototype.registerHybridMethod("findOrAddNewChild", &HybridXmlSpec::findOrAddNewChild);
+      prototype.registerHybridMethod("firstChild", &HybridXmlSpec::firstChild);
+      prototype.registerHybridMethod("firstChild2", &HybridXmlSpec::firstChild2);
+      prototype.registerHybridMethod("getAttrValue", &HybridXmlSpec::getAttrValue);
+      prototype.registerHybridMethod("getAttrValueInt", &HybridXmlSpec::getAttrValueInt);
+      prototype.registerHybridMethod("getAttributeName", &HybridXmlSpec::getAttributeName);
+      prototype.registerHybridMethod("getAttributeValue", &HybridXmlSpec::getAttributeValue);
+      prototype.registerHybridMethod("getAttributeValueInt", &HybridXmlSpec::getAttributeValueInt);
+      prototype.registerHybridMethod("getChild", &HybridXmlSpec::getChild);
+      prototype.registerHybridMethod("getChild2", &HybridXmlSpec::getChild2);
+      prototype.registerHybridMethod("getChildBoolValue", &HybridXmlSpec::getChildBoolValue);
+      prototype.registerHybridMethod("getChildContent", &HybridXmlSpec::getChildContent);
+      prototype.registerHybridMethod("getChildContentByIndex", &HybridXmlSpec::getChildContentByIndex);
+      prototype.registerHybridMethod("getChildExact", &HybridXmlSpec::getChildExact);
+      prototype.registerHybridMethod("getChildIntValue", &HybridXmlSpec::getChildIntValue);
+      prototype.registerHybridMethod("getChildTag", &HybridXmlSpec::getChildTag);
+      prototype.registerHybridMethod("getChildTagByIndex", &HybridXmlSpec::getChildTagByIndex);
+      prototype.registerHybridMethod("getChildWithAttr", &HybridXmlSpec::getChildWithAttr);
+      prototype.registerHybridMethod("getChildWithContent", &HybridXmlSpec::getChildWithContent);
+      prototype.registerHybridMethod("getChildWithTag", &HybridXmlSpec::getChildWithTag);
+      prototype.registerHybridMethod("getNthChildWithTag", &HybridXmlSpec::getNthChildWithTag);
+      prototype.registerHybridMethod("getNthChildWithTag2", &HybridXmlSpec::getNthChildWithTag2);
+      prototype.registerHybridMethod("getParent", &HybridXmlSpec::getParent);
+      prototype.registerHybridMethod("getParent2", &HybridXmlSpec::getParent2);
+      prototype.registerHybridMethod("getRoot", &HybridXmlSpec::getRoot);
+      prototype.registerHybridMethod("getRoot2", &HybridXmlSpec::getRoot2);
+      prototype.registerHybridMethod("getSelf", &HybridXmlSpec::getSelf);
+      prototype.registerHybridMethod("getXml", &HybridXmlSpec::getXml);
+      prototype.registerHybridMethod("hasAttrWithValue", &HybridXmlSpec::hasAttrWithValue);
+      prototype.registerHybridMethod("hasAttribute", &HybridXmlSpec::hasAttribute);
+      prototype.registerHybridMethod("hasChildWithContent", &HybridXmlSpec::hasChildWithContent);
+      prototype.registerHybridMethod("hasChildWithTag", &HybridXmlSpec::hasChildWithTag);
+      prototype.registerHybridMethod("hasChildWithTagAndContent", &HybridXmlSpec::hasChildWithTagAndContent);
+      prototype.registerHybridMethod("insertChildTreeAfter", &HybridXmlSpec::insertChildTreeAfter);
+      prototype.registerHybridMethod("insertChildTreeBefore", &HybridXmlSpec::insertChildTreeBefore);
+      prototype.registerHybridMethod("lastChild", &HybridXmlSpec::lastChild);
+      prototype.registerHybridMethod("lastChild2", &HybridXmlSpec::lastChild2);
+      prototype.registerHybridMethod("loadXml", &HybridXmlSpec::loadXml);
+      prototype.registerHybridMethod("loadXml2", &HybridXmlSpec::loadXml2);
+      prototype.registerHybridMethod("loadXmlFile", &HybridXmlSpec::loadXmlFile);
+      prototype.registerHybridMethod("loadXmlFile2", &HybridXmlSpec::loadXmlFile2);
+      prototype.registerHybridMethod("newChild", &HybridXmlSpec::newChild);
+      prototype.registerHybridMethod("newChild2", &HybridXmlSpec::newChild2);
+      prototype.registerHybridMethod("newChildAfter", &HybridXmlSpec::newChildAfter);
+      prototype.registerHybridMethod("newChildBefore", &HybridXmlSpec::newChildBefore);
+      prototype.registerHybridMethod("newChildInt2", &HybridXmlSpec::newChildInt2);
+      prototype.registerHybridMethod("nextSibling", &HybridXmlSpec::nextSibling);
+      prototype.registerHybridMethod("nextSibling2", &HybridXmlSpec::nextSibling2);
+      prototype.registerHybridMethod("numChildrenHavingTag", &HybridXmlSpec::numChildrenHavingTag);
+      prototype.registerHybridMethod("previousSibling", &HybridXmlSpec::previousSibling);
+      prototype.registerHybridMethod("previousSibling2", &HybridXmlSpec::previousSibling2);
+      prototype.registerHybridMethod("removeAllAttributes", &HybridXmlSpec::removeAllAttributes);
+      prototype.registerHybridMethod("removeAllChildren", &HybridXmlSpec::removeAllChildren);
+      prototype.registerHybridMethod("removeAttribute", &HybridXmlSpec::removeAttribute);
+      prototype.registerHybridMethod("removeChild", &HybridXmlSpec::removeChild);
+      prototype.registerHybridMethod("removeChildByIndex", &HybridXmlSpec::removeChildByIndex);
+      prototype.registerHybridMethod("removeChildWithContent", &HybridXmlSpec::removeChildWithContent);
+      prototype.registerHybridMethod("removeFromTree", &HybridXmlSpec::removeFromTree);
+      prototype.registerHybridMethod("saveBinaryContent", &HybridXmlSpec::saveBinaryContent);
+      prototype.registerHybridMethod("saveXml", &HybridXmlSpec::saveXml);
+      prototype.registerHybridMethod("searchAllForContent", &HybridXmlSpec::searchAllForContent);
+      prototype.registerHybridMethod("searchAllForContent2", &HybridXmlSpec::searchAllForContent2);
+      prototype.registerHybridMethod("searchForAttribute", &HybridXmlSpec::searchForAttribute);
+      prototype.registerHybridMethod("searchForAttribute2", &HybridXmlSpec::searchForAttribute2);
+      prototype.registerHybridMethod("searchForContent", &HybridXmlSpec::searchForContent);
+      prototype.registerHybridMethod("searchForContent2", &HybridXmlSpec::searchForContent2);
+      prototype.registerHybridMethod("searchForTag", &HybridXmlSpec::searchForTag);
+      prototype.registerHybridMethod("searchForTag2", &HybridXmlSpec::searchForTag2);
+      prototype.registerHybridMethod("setBinaryContentFromFile", &HybridXmlSpec::setBinaryContentFromFile);
+      prototype.registerHybridMethod("sortByAttribute", &HybridXmlSpec::sortByAttribute);
+      prototype.registerHybridMethod("sortByAttributeInt", &HybridXmlSpec::sortByAttributeInt);
+      prototype.registerHybridMethod("sortByContent", &HybridXmlSpec::sortByContent);
+      prototype.registerHybridMethod("sortByTag", &HybridXmlSpec::sortByTag);
+      prototype.registerHybridMethod("sortRecordsByAttribute", &HybridXmlSpec::sortRecordsByAttribute);
+      prototype.registerHybridMethod("sortRecordsByContent", &HybridXmlSpec::sortRecordsByContent);
+      prototype.registerHybridMethod("sortRecordsByContentInt", &HybridXmlSpec::sortRecordsByContentInt);
+      prototype.registerHybridMethod("swapNode", &HybridXmlSpec::swapNode);
+      prototype.registerHybridMethod("swapTree", &HybridXmlSpec::swapTree);
+      prototype.registerHybridMethod("tagContent", &HybridXmlSpec::tagContent);
+      prototype.registerHybridMethod("tagEquals", &HybridXmlSpec::tagEquals);
+      prototype.registerHybridMethod("unzipContent", &HybridXmlSpec::unzipContent);
+      prototype.registerHybridMethod("unzipTree", &HybridXmlSpec::unzipTree);
+      prototype.registerHybridMethod("updateAttribute", &HybridXmlSpec::updateAttribute);
+      prototype.registerHybridMethod("updateAttributeInt", &HybridXmlSpec::updateAttributeInt);
+      prototype.registerHybridMethod("updateChildContent", &HybridXmlSpec::updateChildContent);
+      prototype.registerHybridMethod("updateChildContentInt", &HybridXmlSpec::updateChildContentInt);
+      prototype.registerHybridMethod("zipContent", &HybridXmlSpec::zipContent);
+      prototype.registerHybridMethod("zipTree", &HybridXmlSpec::zipTree);
+      prototype.registerHybridMethod("loadSb", &HybridXmlSpec::loadSb);
+      prototype.registerHybridMethod("getXmlSb", &HybridXmlSpec::getXmlSb);
+      prototype.registerHybridMethod("numChildrenAt", &HybridXmlSpec::numChildrenAt);
+      prototype.registerHybridMethod("updateAt", &HybridXmlSpec::updateAt);
+      prototype.registerHybridMethod("updateAttrAt", &HybridXmlSpec::updateAttrAt);
+      prototype.registerHybridMethod("getChildContentSb", &HybridXmlSpec::getChildContentSb);
+      prototype.registerHybridMethod("tagIndex", &HybridXmlSpec::tagIndex);
+      prototype.registerHybridMethod("tagNsEquals", &HybridXmlSpec::tagNsEquals);
+      prototype.registerHybridMethod("tagUnpEquals", &HybridXmlSpec::tagUnpEquals);
+      prototype.registerHybridMethod("getChildAttrValue", &HybridXmlSpec::getChildAttrValue);
+      prototype.registerHybridMethod("removeStyleSheet", &HybridXmlSpec::removeStyleSheet);
+      prototype.registerHybridMethod("pruneAttribute", &HybridXmlSpec::pruneAttribute);
+      prototype.registerHybridMethod("pruneTag", &HybridXmlSpec::pruneTag);
+      prototype.registerHybridMethod("scrub", &HybridXmlSpec::scrub);
+      prototype.registerHybridMethod("loadBd", &HybridXmlSpec::loadBd);
+      prototype.registerHybridMethod("getXmlBd", &HybridXmlSpec::getXmlBd);
+      prototype.registerHybridMethod("nextInTraversal2", &HybridXmlSpec::nextInTraversal2);
+      prototype.registerHybridMethod("setBinaryContentBd", &HybridXmlSpec::setBinaryContentBd);
+      prototype.registerHybridMethod("getChildWithTag2", &HybridXmlSpec::getChildWithTag2);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat