@chilkat/react-native 11.6.1

package/cpp/HybridXml.hpp

@@ -0,0 +1,340 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Xml: the Nitro HybridObject over Chilkat's CkXml (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridXmlSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkXml.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridXml final : public HybridXmlSpec, public ChilkatObject<CkXml> {
+public:
+  HybridXml();                                  // `new Xml()` from JS
+  explicit HybridXml(CkXml* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  bool getCdata() override;
+  void setCdata(bool value) override;
+  std::string getContent() override;
+  void setContent(const std::string& value) override;
+  double getContentInt() override;
+  void setContentInt(double value) override;
+  std::string getDocType() override;
+  void setDocType(const std::string& value) override;
+  bool getEmitBom() override;
+  void setEmitBom(bool value) override;
+  bool getEmitXmlDecl() override;
+  void setEmitXmlDecl(bool value) override;
+  std::string getEncoding() override;
+  void setEncoding(const std::string& value) override;
+  double getNumAttributes() override;
+  double getNumChildren() override;
+  bool getSortCaseInsensitive() override;
+  void setSortCaseInsensitive(bool value) override;
+  bool getStandalone() override;
+  void setStandalone(bool value) override;
+  bool getStrict() override;
+  void setStrict(bool value) override;
+  std::string getTag() override;
+  void setTag(const std::string& value) override;
+  double getTreeId() override;
+  double getI() override;
+  void setI(double value) override;
+  double getJ() override;
+  void setJ(double value) override;
+  double getK() override;
+  void setK(double value) override;
+  bool getEmitCompact() override;
+  void setEmitCompact(bool value) override;
+  bool getIsBase64() override;
+  std::string getTagNsPrefix() override;
+  void setTagNsPrefix(const std::string& value) override;
+  std::string getTagUnprefixed() override;
+  void setTagUnprefixed(const std::string& value) override;
+  std::string getTagPath() override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+
+  // ---- Methods ----
+  std::string accumulateTagContent(const std::string& tag, const std::string& skipTags) override;
+  void addAttribute(const std::string& name, const std::string& value) override;
+  void addAttributeInt(const std::string& name, double value) override;
+  void addChildTree(const std::shared_ptr<HybridXmlSpec>& tree) override;
+  void addOrUpdateAttribute(const std::string& name, const std::string& value) override;
+  void addOrUpdateAttributeI(const std::string& name, double value) override;
+  void addStyleSheet(const std::string& styleSheet) override;
+  void addToAttribute(const std::string& name, double amount) override;
+  void addToChildContent(const std::string& tag, double amount) override;
+  void addToContent(double amount) override;
+  void appendToContent(const std::string& str) override;
+  bool childContentMatches(const std::string& tagPath, const std::string& pattern, bool caseSensitive) override;
+  std::string chilkatPath(const std::string& pathCmd) override;
+  void clear() override;
+  bool contentMatches(const std::string& pattern, bool caseSensitive) override;
+  void copy(const std::shared_ptr<HybridXmlSpec>& node) override;
+  void copyRef(const std::shared_ptr<HybridXmlSpec>& copyFromNode) override;
+  std::string decodeEntities(const std::string& str) override;
+  void decryptContent(const std::string& password) override;
+  void encryptContent(const std::string& password) override;
+  std::shared_ptr<HybridXmlSpec> extractChildByIndex(double index) override;
+  std::shared_ptr<HybridXmlSpec> extractChildByName(const std::string& tagPath, const std::string& attrName, const std::string& attrValue) override;
+  std::shared_ptr<HybridXmlSpec> findChild(const std::string& tagPath) override;
+  void findChild2(const std::string& tagPath) override;
+  std::shared_ptr<HybridXmlSpec> findNextRecord(const std::string& tagPath, const std::string& contentPattern) override;
+  std::shared_ptr<HybridXmlSpec> findOrAddNewChild(const std::string& tagPath) override;
+  std::shared_ptr<HybridXmlSpec> firstChild() override;
+  bool firstChild2() override;
+  std::string getAttrValue(const std::string& name) override;
+  double getAttrValueInt(const std::string& name) override;
+  std::string getAttributeName(double index) override;
+  std::string getAttributeValue(double index) override;
+  double getAttributeValueInt(double index) override;
+  std::shared_ptr<HybridXmlSpec> getChild(double index) override;
+  void getChild2(double index) override;
+  bool getChildBoolValue(const std::string& tagPath) override;
+  std::string getChildContent(const std::string& tagPath) override;
+  std::string getChildContentByIndex(double index) override;
+  std::shared_ptr<HybridXmlSpec> getChildExact(const std::string& tag, const std::string& content) override;
+  double getChildIntValue(const std::string& tagPath) override;
+  std::string getChildTag(double index) override;
+  std::string getChildTagByIndex(double index) override;
+  std::shared_ptr<HybridXmlSpec> getChildWithAttr(const std::string& tagPath, const std::string& attrName, const std::string& attrValue) override;
+  std::shared_ptr<HybridXmlSpec> getChildWithContent(const std::string& content) override;
+  std::shared_ptr<HybridXmlSpec> getChildWithTag(const std::string& tagPath) override;
+  std::shared_ptr<HybridXmlSpec> getNthChildWithTag(const std::string& tag, double n) override;
+  void getNthChildWithTag2(const std::string& tag, double n) override;
+  std::shared_ptr<HybridXmlSpec> getParent() override;
+  void getParent2() override;
+  std::shared_ptr<HybridXmlSpec> getRoot() override;
+  void getRoot2() override;
+  std::shared_ptr<HybridXmlSpec> getSelf() override;
+  std::string getXml() override;
+  bool hasAttrWithValue(const std::string& name, const std::string& value) override;
+  bool hasAttribute(const std::string& name) override;
+  bool hasChildWithContent(const std::string& content) override;
+  bool hasChildWithTag(const std::string& tagPath) override;
+  bool hasChildWithTagAndContent(const std::string& tagPath, const std::string& content) override;
+  void insertChildTreeAfter(double index, const std::shared_ptr<HybridXmlSpec>& tree) override;
+  void insertChildTreeBefore(double index, const std::shared_ptr<HybridXmlSpec>& tree) override;
+  std::shared_ptr<HybridXmlSpec> lastChild() override;
+  void lastChild2() override;
+  void loadXml(const std::string& xmlData) override;
+  void loadXml2(const std::string& xmlData, bool autoTrim) override;
+  void loadXmlFile(const std::string& fileName) override;
+  void loadXmlFile2(const std::string& fileName, bool autoTrim) override;
+  std::shared_ptr<HybridXmlSpec> newChild(const std::string& tagPath, const std::string& content) override;
+  void newChild2(const std::string& tagPath, const std::string& content) override;
+  std::shared_ptr<HybridXmlSpec> newChildAfter(double index, const std::string& tag, const std::string& content) override;
+  std::shared_ptr<HybridXmlSpec> newChildBefore(double index, const std::string& tag, const std::string& content) override;
+  void newChildInt2(const std::string& tagPath, double value) override;
+  std::shared_ptr<HybridXmlSpec> nextSibling() override;
+  bool nextSibling2() override;
+  double numChildrenHavingTag(const std::string& tag) override;
+  std::shared_ptr<HybridXmlSpec> previousSibling() override;
+  void previousSibling2() override;
+  void removeAllAttributes() override;
+  void removeAllChildren() override;
+  void removeAttribute(const std::string& name) override;
+  void removeChild(const std::string& tagPath) override;
+  void removeChildByIndex(double index) override;
+  void removeChildWithContent(const std::string& content) override;
+  void removeFromTree() override;
+  void saveBinaryContent(const std::string& filename, bool unzipFlag, bool decryptFlag, const std::string& password) override;
+  void saveXml(const std::string& fileName) override;
+  std::shared_ptr<HybridXmlSpec> searchAllForContent(const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) override;
+  void searchAllForContent2(const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) override;
+  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) override;
+  void searchForAttribute2(const std::string& tag, const std::string& attr, const std::string& valuePattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) override;
+  std::shared_ptr<HybridXmlSpec> searchForContent(const std::string& tag, const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) override;
+  void searchForContent2(const std::string& tag, const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) override;
+  std::shared_ptr<HybridXmlSpec> searchForTag(const std::string& tag, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) override;
+  void searchForTag2(const std::string& tag, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) override;
+  void setBinaryContentFromFile(const std::string& filename, bool zipFlag, bool encryptFlag, const std::string& password) override;
+  void sortByAttribute(const std::string& attrName, bool ascending) override;
+  void sortByAttributeInt(const std::string& attrName, bool ascending) override;
+  void sortByContent(bool ascending) override;
+  void sortByTag(bool ascending) override;
+  void sortRecordsByAttribute(const std::string& sortTag, const std::string& attrName, bool ascending) override;
+  void sortRecordsByContent(const std::string& sortTag, bool ascending) override;
+  void sortRecordsByContentInt(const std::string& sortTag, bool ascending) override;
+  void swapNode(const std::shared_ptr<HybridXmlSpec>& node) override;
+  void swapTree(const std::shared_ptr<HybridXmlSpec>& tree) override;
+  std::string tagContent(const std::string& tagName) override;
+  bool tagEquals(const std::string& tag) override;
+  void unzipContent() override;
+  void unzipTree() override;
+  void updateAttribute(const std::string& attrName, const std::string& attrValue) override;
+  void updateAttributeInt(const std::string& attrName, double value) override;
+  void updateChildContent(const std::string& tagPath, const std::string& value) override;
+  void updateChildContentInt(const std::string& tagPath, double value) override;
+  void zipContent() override;
+  void zipTree() override;
+  void loadSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool autoTrim) override;
+  void getXmlSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  double numChildrenAt(const std::string& tagPath) override;
+  void updateAt(const std::string& tagPath, bool autoCreate, const std::string& value) override;
+  void updateAttrAt(const std::string& tagPath, bool autoCreate, const std::string& attrName, const std::string& attrValue) override;
+  void getChildContentSb(const std::string& tagPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  double tagIndex(const std::string& tagPath) override;
+  bool tagNsEquals(const std::string& ns) override;
+  bool tagUnpEquals(const std::string& unprefixedTag) override;
+  std::string getChildAttrValue(const std::string& tagPath, const std::string& attrName) override;
+  double removeStyleSheet(const std::string& attrName, const std::string& attrValue) override;
+  double pruneAttribute(const std::string& attrName) override;
+  double pruneTag(const std::string& tag) override;
+  void scrub(const std::string& directives) override;
+  void loadBd(const std::shared_ptr<HybridBinDataSpec>& bd, bool autoTrim) override;
+  void getXmlBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  bool nextInTraversal2(const std::shared_ptr<HybridStringBuilderSpec>& sbState) override;
+  void setBinaryContentBd(const std::shared_ptr<HybridBinDataSpec>& data, bool zipFlag, bool encryptFlag, const std::string& password) override;
+  void getChildWithTag2(const std::string& tagPath) override;
+
+private:
+  void init();
+  std::string accumulateTagContent_impl(const std::string& tag, const std::string& skipTags);
+  void addAttribute_impl(const std::string& name, const std::string& value);
+  void addAttributeInt_impl(const std::string& name, double value);
+  void addChildTree_impl(const std::shared_ptr<HybridXmlSpec>& tree);
+  void addOrUpdateAttribute_impl(const std::string& name, const std::string& value);
+  void addOrUpdateAttributeI_impl(const std::string& name, double value);
+  void addStyleSheet_impl(const std::string& styleSheet);
+  void addToAttribute_impl(const std::string& name, double amount);
+  void addToChildContent_impl(const std::string& tag, double amount);
+  void addToContent_impl(double amount);
+  void appendToContent_impl(const std::string& str);
+  bool childContentMatches_impl(const std::string& tagPath, const std::string& pattern, bool caseSensitive);
+  std::string chilkatPath_impl(const std::string& pathCmd);
+  void clear_impl();
+  bool contentMatches_impl(const std::string& pattern, bool caseSensitive);
+  void copy_impl(const std::shared_ptr<HybridXmlSpec>& node);
+  void copyRef_impl(const std::shared_ptr<HybridXmlSpec>& copyFromNode);
+  std::string decodeEntities_impl(const std::string& str);
+  void decryptContent_impl(const std::string& password);
+  void encryptContent_impl(const std::string& password);
+  std::shared_ptr<HybridXmlSpec> extractChildByIndex_impl(double index);
+  std::shared_ptr<HybridXmlSpec> extractChildByName_impl(const std::string& tagPath, const std::string& attrName, const std::string& attrValue);
+  std::shared_ptr<HybridXmlSpec> findChild_impl(const std::string& tagPath);
+  void findChild2_impl(const std::string& tagPath);
+  std::shared_ptr<HybridXmlSpec> findNextRecord_impl(const std::string& tagPath, const std::string& contentPattern);
+  std::shared_ptr<HybridXmlSpec> findOrAddNewChild_impl(const std::string& tagPath);
+  std::shared_ptr<HybridXmlSpec> firstChild_impl();
+  bool firstChild2_impl();
+  std::string getAttrValue_impl(const std::string& name);
+  double getAttrValueInt_impl(const std::string& name);
+  std::string getAttributeName_impl(double index);
+  std::string getAttributeValue_impl(double index);
+  double getAttributeValueInt_impl(double index);
+  std::shared_ptr<HybridXmlSpec> getChild_impl(double index);
+  void getChild2_impl(double index);
+  bool getChildBoolValue_impl(const std::string& tagPath);
+  std::string getChildContent_impl(const std::string& tagPath);
+  std::string getChildContentByIndex_impl(double index);
+  std::shared_ptr<HybridXmlSpec> getChildExact_impl(const std::string& tag, const std::string& content);
+  double getChildIntValue_impl(const std::string& tagPath);
+  std::string getChildTag_impl(double index);
+  std::string getChildTagByIndex_impl(double index);
+  std::shared_ptr<HybridXmlSpec> getChildWithAttr_impl(const std::string& tagPath, const std::string& attrName, const std::string& attrValue);
+  std::shared_ptr<HybridXmlSpec> getChildWithContent_impl(const std::string& content);
+  std::shared_ptr<HybridXmlSpec> getChildWithTag_impl(const std::string& tagPath);
+  std::shared_ptr<HybridXmlSpec> getNthChildWithTag_impl(const std::string& tag, double n);
+  void getNthChildWithTag2_impl(const std::string& tag, double n);
+  std::shared_ptr<HybridXmlSpec> getParent_impl();
+  void getParent2_impl();
+  std::shared_ptr<HybridXmlSpec> getRoot_impl();
+  void getRoot2_impl();
+  std::shared_ptr<HybridXmlSpec> getSelf_impl();
+  std::string getXml_impl();
+  bool hasAttrWithValue_impl(const std::string& name, const std::string& value);
+  bool hasAttribute_impl(const std::string& name);
+  bool hasChildWithContent_impl(const std::string& content);
+  bool hasChildWithTag_impl(const std::string& tagPath);
+  bool hasChildWithTagAndContent_impl(const std::string& tagPath, const std::string& content);
+  void insertChildTreeAfter_impl(double index, const std::shared_ptr<HybridXmlSpec>& tree);
+  void insertChildTreeBefore_impl(double index, const std::shared_ptr<HybridXmlSpec>& tree);
+  std::shared_ptr<HybridXmlSpec> lastChild_impl();
+  void lastChild2_impl();
+  void loadXml_impl(const std::string& xmlData);
+  void loadXml2_impl(const std::string& xmlData, bool autoTrim);
+  void loadXmlFile_impl(const std::string& fileName);
+  void loadXmlFile2_impl(const std::string& fileName, bool autoTrim);
+  std::shared_ptr<HybridXmlSpec> newChild_impl(const std::string& tagPath, const std::string& content);
+  void newChild2_impl(const std::string& tagPath, const std::string& content);
+  std::shared_ptr<HybridXmlSpec> newChildAfter_impl(double index, const std::string& tag, const std::string& content);
+  std::shared_ptr<HybridXmlSpec> newChildBefore_impl(double index, const std::string& tag, const std::string& content);
+  void newChildInt2_impl(const std::string& tagPath, double value);
+  std::shared_ptr<HybridXmlSpec> nextSibling_impl();
+  bool nextSibling2_impl();
+  double numChildrenHavingTag_impl(const std::string& tag);
+  std::shared_ptr<HybridXmlSpec> previousSibling_impl();
+  void previousSibling2_impl();
+  void removeAllAttributes_impl();
+  void removeAllChildren_impl();
+  void removeAttribute_impl(const std::string& name);
+  void removeChild_impl(const std::string& tagPath);
+  void removeChildByIndex_impl(double index);
+  void removeChildWithContent_impl(const std::string& content);
+  void removeFromTree_impl();
+  void saveBinaryContent_impl(const std::string& filename, bool unzipFlag, bool decryptFlag, const std::string& password);
+  void saveXml_impl(const std::string& fileName);
+  std::shared_ptr<HybridXmlSpec> searchAllForContent_impl(const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after);
+  void searchAllForContent2_impl(const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after);
+  std::shared_ptr<HybridXmlSpec> searchForAttribute_impl(const std::string& tag, const std::string& attr, const std::string& valuePattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after);
+  void searchForAttribute2_impl(const std::string& tag, const std::string& attr, const std::string& valuePattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after);
+  std::shared_ptr<HybridXmlSpec> searchForContent_impl(const std::string& tag, const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after);
+  void searchForContent2_impl(const std::string& tag, const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after);
+  std::shared_ptr<HybridXmlSpec> searchForTag_impl(const std::string& tag, const std::optional<std::shared_ptr<HybridXmlSpec>>& after);
+  void searchForTag2_impl(const std::string& tag, const std::optional<std::shared_ptr<HybridXmlSpec>>& after);
+  void setBinaryContentFromFile_impl(const std::string& filename, bool zipFlag, bool encryptFlag, const std::string& password);
+  void sortByAttribute_impl(const std::string& attrName, bool ascending);
+  void sortByAttributeInt_impl(const std::string& attrName, bool ascending);
+  void sortByContent_impl(bool ascending);
+  void sortByTag_impl(bool ascending);
+  void sortRecordsByAttribute_impl(const std::string& sortTag, const std::string& attrName, bool ascending);
+  void sortRecordsByContent_impl(const std::string& sortTag, bool ascending);
+  void sortRecordsByContentInt_impl(const std::string& sortTag, bool ascending);
+  void swapNode_impl(const std::shared_ptr<HybridXmlSpec>& node);
+  void swapTree_impl(const std::shared_ptr<HybridXmlSpec>& tree);
+  std::string tagContent_impl(const std::string& tagName);
+  bool tagEquals_impl(const std::string& tag);
+  void unzipContent_impl();
+  void unzipTree_impl();
+  void updateAttribute_impl(const std::string& attrName, const std::string& attrValue);
+  void updateAttributeInt_impl(const std::string& attrName, double value);
+  void updateChildContent_impl(const std::string& tagPath, const std::string& value);
+  void updateChildContentInt_impl(const std::string& tagPath, double value);
+  void zipContent_impl();
+  void zipTree_impl();
+  void loadSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool autoTrim);
+  void getXmlSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  double numChildrenAt_impl(const std::string& tagPath);
+  void updateAt_impl(const std::string& tagPath, bool autoCreate, const std::string& value);
+  void updateAttrAt_impl(const std::string& tagPath, bool autoCreate, const std::string& attrName, const std::string& attrValue);
+  void getChildContentSb_impl(const std::string& tagPath, const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  double tagIndex_impl(const std::string& tagPath);
+  bool tagNsEquals_impl(const std::string& ns);
+  bool tagUnpEquals_impl(const std::string& unprefixedTag);
+  std::string getChildAttrValue_impl(const std::string& tagPath, const std::string& attrName);
+  double removeStyleSheet_impl(const std::string& attrName, const std::string& attrValue);
+  double pruneAttribute_impl(const std::string& attrName);
+  double pruneTag_impl(const std::string& tag);
+  void scrub_impl(const std::string& directives);
+  void loadBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, bool autoTrim);
+  void getXmlBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  bool nextInTraversal2_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbState);
+  void setBinaryContentBd_impl(const std::shared_ptr<HybridBinDataSpec>& data, bool zipFlag, bool encryptFlag, const std::string& password);
+  void getChildWithTag2_impl(const std::string& tagPath);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridXmlCertVault.cpp

@@ -0,0 +1,215 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridXmlCertVault.hpp"
+#include "HybridCert.hpp"
+#include "HybridCertChain.hpp"
+#include "HybridPfx.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridXmlCertVault::HybridXmlCertVault()
+    : HybridObject(HybridXmlCertVaultSpec::TAG), ChilkatObject<CkXmlCertVault>("XmlCertVault", CkXmlCertVault::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridXmlCertVault::HybridXmlCertVault(CkXmlCertVault* owned)
+    : HybridObject(HybridXmlCertVaultSpec::TAG), ChilkatObject<CkXmlCertVault>("XmlCertVault", owned) {
+  init();
+}
+
+void HybridXmlCertVault::init() {
+}
+
+void HybridXmlCertVault::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridXmlCertVault::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridXmlCertVault::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridXmlCertVault::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridXmlCertVault::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridXmlCertVault::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridXmlCertVault::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridXmlCertVault::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridXmlCertVault::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridXmlCertVault::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridXmlCertVault::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridXmlCertVault::getMasterPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_MasterPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridXmlCertVault::setMasterPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "masterPassword");
+  this->ck().put_MasterPassword(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridXmlCertVault::addCert(const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  addCert_impl(cert);
+}
+void HybridXmlCertVault::addCert_impl(const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().AddCert(rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("addCert");
+}
+
+void HybridXmlCertVault::addCertChain(const std::shared_ptr<HybridCertChainSpec>& certChain) {
+  this->beginCall();
+  addCertChain_impl(certChain);
+}
+void HybridXmlCertVault::addCertChain_impl(const std::shared_ptr<HybridCertChainSpec>& certChain) {
+  if (!this->ck().AddCertChain(rt::implOf<HybridCertChain>(certChain, "certChain").ck())) throw this->fail("addCertChain");
+}
+
+void HybridXmlCertVault::addCertEncoded(const std::string& encodedBytes, const std::string& encoding) {
+  this->beginCall();
+  addCertEncoded_impl(encodedBytes, encoding);
+}
+void HybridXmlCertVault::addCertEncoded_impl(const std::string& encodedBytes, const std::string& encoding) {
+  rt::checkNoNul(encodedBytes, "encodedBytes");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().AddCertEncoded(encodedBytes.c_str(), encoding.c_str())) throw this->fail("addCertEncoded");
+}
+
+void HybridXmlCertVault::addCertFile(const std::string& path) {
+  this->beginCall();
+  addCertFile_impl(path);
+}
+void HybridXmlCertVault::addCertFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().AddCertFile(path.c_str())) throw this->fail("addCertFile");
+}
+
+void HybridXmlCertVault::addCertString(const std::string& certData) {
+  this->beginCall();
+  addCertString_impl(certData);
+}
+void HybridXmlCertVault::addCertString_impl(const std::string& certData) {
+  rt::checkNoNul(certData, "certData");
+  if (!this->ck().AddCertString(certData.c_str())) throw this->fail("addCertString");
+}
+
+void HybridXmlCertVault::addPemFile(const std::string& path, const std::string& password) {
+  this->beginCall();
+  addPemFile_impl(path, password);
+}
+void HybridXmlCertVault::addPemFile_impl(const std::string& path, const std::string& password) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().AddPemFile(path.c_str(), password.c_str())) throw this->fail("addPemFile");
+}
+
+void HybridXmlCertVault::addPfx(const std::shared_ptr<HybridPfxSpec>& pfx) {
+  this->beginCall();
+  addPfx_impl(pfx);
+}
+void HybridXmlCertVault::addPfx_impl(const std::shared_ptr<HybridPfxSpec>& pfx) {
+  if (!this->ck().AddPfx(rt::implOf<HybridPfx>(pfx, "pfx").ck())) throw this->fail("addPfx");
+}
+
+void HybridXmlCertVault::addPfxEncoded(const std::string& encodedBytes, const std::string& encoding, const std::string& password) {
+  this->beginCall();
+  addPfxEncoded_impl(encodedBytes, encoding, password);
+}
+void HybridXmlCertVault::addPfxEncoded_impl(const std::string& encodedBytes, const std::string& encoding, const std::string& password) {
+  rt::checkNoNul(encodedBytes, "encodedBytes");
+  rt::checkNoNul(encoding, "encoding");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().AddPfxEncoded(encodedBytes.c_str(), encoding.c_str(), password.c_str())) throw this->fail("addPfxEncoded");
+}
+
+void HybridXmlCertVault::addPfxFile(const std::string& path, const std::string& password) {
+  this->beginCall();
+  addPfxFile_impl(path, password);
+}
+void HybridXmlCertVault::addPfxFile_impl(const std::string& path, const std::string& password) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().AddPfxFile(path.c_str(), password.c_str())) throw this->fail("addPfxFile");
+}
+
+std::string HybridXmlCertVault::getXml() {
+  this->beginCall();
+  return getXml_impl();
+}
+std::string HybridXmlCertVault::getXml_impl() {
+  CkString _out;
+  if (!this->ck().GetXml(_out)) throw this->fail("getXml");
+  return rt::stdString(_out);
+}
+
+void HybridXmlCertVault::loadXml(const std::string& xml) {
+  this->beginCall();
+  loadXml_impl(xml);
+}
+void HybridXmlCertVault::loadXml_impl(const std::string& xml) {
+  rt::checkNoNul(xml, "xml");
+  if (!this->ck().LoadXml(xml.c_str())) throw this->fail("loadXml");
+}
+
+void HybridXmlCertVault::loadXmlFile(const std::string& path) {
+  this->beginCall();
+  loadXmlFile_impl(path);
+}
+void HybridXmlCertVault::loadXmlFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().LoadXmlFile(path.c_str())) throw this->fail("loadXmlFile");
+}
+
+void HybridXmlCertVault::saveXml(const std::string& path) {
+  this->beginCall();
+  saveXml_impl(path);
+}
+void HybridXmlCertVault::saveXml_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SaveXml(path.c_str())) throw this->fail("saveXml");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridXmlCertVault.hpp

@@ -0,0 +1,63 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// XmlCertVault: the Nitro HybridObject over Chilkat's CkXmlCertVault (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridXmlCertVaultSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkXmlCertVault.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridXmlCertVault final : public HybridXmlCertVaultSpec, public ChilkatObject<CkXmlCertVault> {
+public:
+  HybridXmlCertVault();                                  // `new XmlCertVault()` from JS
+  explicit HybridXmlCertVault(CkXmlCertVault* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  std::string getMasterPassword() override;
+  void setMasterPassword(const std::string& value) override;
+
+  // ---- Methods ----
+  void addCert(const std::shared_ptr<HybridCertSpec>& cert) override;
+  void addCertChain(const std::shared_ptr<HybridCertChainSpec>& certChain) override;
+  void addCertEncoded(const std::string& encodedBytes, const std::string& encoding) override;
+  void addCertFile(const std::string& path) override;
+  void addCertString(const std::string& certData) override;
+  void addPemFile(const std::string& path, const std::string& password) override;
+  void addPfx(const std::shared_ptr<HybridPfxSpec>& pfx) override;
+  void addPfxEncoded(const std::string& encodedBytes, const std::string& encoding, const std::string& password) override;
+  void addPfxFile(const std::string& path, const std::string& password) override;
+  std::string getXml() override;
+  void loadXml(const std::string& xml) override;
+  void loadXmlFile(const std::string& path) override;
+  void saveXml(const std::string& path) override;
+
+private:
+  void init();
+  void addCert_impl(const std::shared_ptr<HybridCertSpec>& cert);
+  void addCertChain_impl(const std::shared_ptr<HybridCertChainSpec>& certChain);
+  void addCertEncoded_impl(const std::string& encodedBytes, const std::string& encoding);
+  void addCertFile_impl(const std::string& path);
+  void addCertString_impl(const std::string& certData);
+  void addPemFile_impl(const std::string& path, const std::string& password);
+  void addPfx_impl(const std::shared_ptr<HybridPfxSpec>& pfx);
+  void addPfxEncoded_impl(const std::string& encodedBytes, const std::string& encoding, const std::string& password);
+  void addPfxFile_impl(const std::string& path, const std::string& password);
+  std::string getXml_impl();
+  void loadXml_impl(const std::string& xml);
+  void loadXmlFile_impl(const std::string& path);
+  void saveXml_impl(const std::string& path);
+};
+
+} // namespace margelo::nitro::chilkat