@chilkat/react-native 11.6.1

package/cpp/HybridXml.cpp

@@ -0,0 +1,1527 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridXml.hpp"
+#include "HybridBinData.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridXml::HybridXml()
+    : HybridObject(HybridXmlSpec::TAG), ChilkatObject<CkXml>("Xml", CkXml::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridXml::HybridXml(CkXml* owned)
+    : HybridObject(HybridXmlSpec::TAG), ChilkatObject<CkXml>("Xml", owned) {
+  init();
+}
+
+void HybridXml::init() {
+}
+
+void HybridXml::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridXml::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridXml::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridXml::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridXml::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridXml::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridXml::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridXml::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridXml::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridXml::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridXml::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridXml::getCdata() {
+  this->beginCall();
+  return this->ck().get_Cdata();
+}
+void HybridXml::setCdata(bool value) {
+  this->beginCall();
+  this->ck().put_Cdata(value);
+}
+std::string HybridXml::getContent() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Content(_s);
+  return rt::stdString(_s);
+}
+void HybridXml::setContent(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "content");
+  this->ck().put_Content(value.c_str());
+}
+double HybridXml::getContentInt() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ContentInt());
+}
+void HybridXml::setContentInt(double value) {
+  this->beginCall();
+  this->ck().put_ContentInt(rt::toInt(value, "contentInt"));
+}
+std::string HybridXml::getDocType() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DocType(_s);
+  return rt::stdString(_s);
+}
+void HybridXml::setDocType(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "docType");
+  this->ck().put_DocType(value.c_str());
+}
+bool HybridXml::getEmitBom() {
+  this->beginCall();
+  return this->ck().get_EmitBom();
+}
+void HybridXml::setEmitBom(bool value) {
+  this->beginCall();
+  this->ck().put_EmitBom(value);
+}
+bool HybridXml::getEmitXmlDecl() {
+  this->beginCall();
+  return this->ck().get_EmitXmlDecl();
+}
+void HybridXml::setEmitXmlDecl(bool value) {
+  this->beginCall();
+  this->ck().put_EmitXmlDecl(value);
+}
+std::string HybridXml::getEncoding() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Encoding(_s);
+  return rt::stdString(_s);
+}
+void HybridXml::setEncoding(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "encoding");
+  this->ck().put_Encoding(value.c_str());
+}
+double HybridXml::getNumAttributes() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumAttributes());
+}
+double HybridXml::getNumChildren() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumChildren());
+}
+bool HybridXml::getSortCaseInsensitive() {
+  this->beginCall();
+  return this->ck().get_SortCaseInsensitive();
+}
+void HybridXml::setSortCaseInsensitive(bool value) {
+  this->beginCall();
+  this->ck().put_SortCaseInsensitive(value);
+}
+bool HybridXml::getStandalone() {
+  this->beginCall();
+  return this->ck().get_Standalone();
+}
+void HybridXml::setStandalone(bool value) {
+  this->beginCall();
+  this->ck().put_Standalone(value);
+}
+bool HybridXml::getStrict() {
+  this->beginCall();
+  return this->ck().get_Strict();
+}
+void HybridXml::setStrict(bool value) {
+  this->beginCall();
+  this->ck().put_Strict(value);
+}
+std::string HybridXml::getTag() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Tag(_s);
+  return rt::stdString(_s);
+}
+void HybridXml::setTag(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "tag");
+  this->ck().put_Tag(value.c_str());
+}
+double HybridXml::getTreeId() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_TreeId());
+}
+double HybridXml::getI() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_I());
+}
+void HybridXml::setI(double value) {
+  this->beginCall();
+  this->ck().put_I(rt::toInt(value, "i"));
+}
+double HybridXml::getJ() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_J());
+}
+void HybridXml::setJ(double value) {
+  this->beginCall();
+  this->ck().put_J(rt::toInt(value, "j"));
+}
+double HybridXml::getK() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_K());
+}
+void HybridXml::setK(double value) {
+  this->beginCall();
+  this->ck().put_K(rt::toInt(value, "k"));
+}
+bool HybridXml::getEmitCompact() {
+  this->beginCall();
+  return this->ck().get_EmitCompact();
+}
+void HybridXml::setEmitCompact(bool value) {
+  this->beginCall();
+  this->ck().put_EmitCompact(value);
+}
+bool HybridXml::getIsBase64() {
+  this->beginCall();
+  return this->ck().get_IsBase64();
+}
+std::string HybridXml::getTagNsPrefix() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TagNsPrefix(_s);
+  return rt::stdString(_s);
+}
+void HybridXml::setTagNsPrefix(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "tagNsPrefix");
+  this->ck().put_TagNsPrefix(value.c_str());
+}
+std::string HybridXml::getTagUnprefixed() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TagUnprefixed(_s);
+  return rt::stdString(_s);
+}
+void HybridXml::setTagUnprefixed(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "tagUnprefixed");
+  this->ck().put_TagUnprefixed(value.c_str());
+}
+std::string HybridXml::getTagPath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_TagPath(_s);
+  return rt::stdString(_s);
+}
+std::string HybridXml::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridXml::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+std::string HybridXml::accumulateTagContent(const std::string& tag, const std::string& skipTags) {
+  this->beginCall();
+  return accumulateTagContent_impl(tag, skipTags);
+}
+std::string HybridXml::accumulateTagContent_impl(const std::string& tag, const std::string& skipTags) {
+  rt::checkNoNul(tag, "tag");
+  rt::checkNoNul(skipTags, "skipTags");
+  CkString _out;
+  if (!this->ck().AccumulateTagContent(tag.c_str(), skipTags.c_str(), _out)) throw this->fail("accumulateTagContent");
+  return rt::stdString(_out);
+}
+
+void HybridXml::addAttribute(const std::string& name, const std::string& value) {
+  this->beginCall();
+  addAttribute_impl(name, value);
+}
+void HybridXml::addAttribute_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().AddAttribute(name.c_str(), value.c_str())) throw this->fail("addAttribute");
+}
+
+void HybridXml::addAttributeInt(const std::string& name, double value) {
+  this->beginCall();
+  addAttributeInt_impl(name, value);
+}
+void HybridXml::addAttributeInt_impl(const std::string& name, double value) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AddAttributeInt(name.c_str(), rt::toInt(value, "value"))) throw this->fail("addAttributeInt");
+}
+
+void HybridXml::addChildTree(const std::shared_ptr<HybridXmlSpec>& tree) {
+  this->beginCall();
+  addChildTree_impl(tree);
+}
+void HybridXml::addChildTree_impl(const std::shared_ptr<HybridXmlSpec>& tree) {
+  if (!this->ck().AddChildTree(rt::implOf<HybridXml>(tree, "tree").ck())) throw this->fail("addChildTree");
+}
+
+void HybridXml::addOrUpdateAttribute(const std::string& name, const std::string& value) {
+  this->beginCall();
+  addOrUpdateAttribute_impl(name, value);
+}
+void HybridXml::addOrUpdateAttribute_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  this->ck().AddOrUpdateAttribute(name.c_str(), value.c_str());
+}
+
+void HybridXml::addOrUpdateAttributeI(const std::string& name, double value) {
+  this->beginCall();
+  addOrUpdateAttributeI_impl(name, value);
+}
+void HybridXml::addOrUpdateAttributeI_impl(const std::string& name, double value) {
+  rt::checkNoNul(name, "name");
+  this->ck().AddOrUpdateAttributeI(name.c_str(), rt::toInt(value, "value"));
+}
+
+void HybridXml::addStyleSheet(const std::string& styleSheet) {
+  this->beginCall();
+  addStyleSheet_impl(styleSheet);
+}
+void HybridXml::addStyleSheet_impl(const std::string& styleSheet) {
+  rt::checkNoNul(styleSheet, "styleSheet");
+  this->ck().AddStyleSheet(styleSheet.c_str());
+}
+
+void HybridXml::addToAttribute(const std::string& name, double amount) {
+  this->beginCall();
+  addToAttribute_impl(name, amount);
+}
+void HybridXml::addToAttribute_impl(const std::string& name, double amount) {
+  rt::checkNoNul(name, "name");
+  this->ck().AddToAttribute(name.c_str(), rt::toInt(amount, "amount"));
+}
+
+void HybridXml::addToChildContent(const std::string& tag, double amount) {
+  this->beginCall();
+  addToChildContent_impl(tag, amount);
+}
+void HybridXml::addToChildContent_impl(const std::string& tag, double amount) {
+  rt::checkNoNul(tag, "tag");
+  this->ck().AddToChildContent(tag.c_str(), rt::toInt(amount, "amount"));
+}
+
+void HybridXml::addToContent(double amount) {
+  this->beginCall();
+  addToContent_impl(amount);
+}
+void HybridXml::addToContent_impl(double amount) {
+  this->ck().AddToContent(rt::toInt(amount, "amount"));
+}
+
+void HybridXml::appendToContent(const std::string& str) {
+  this->beginCall();
+  appendToContent_impl(str);
+}
+void HybridXml::appendToContent_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  if (!this->ck().AppendToContent(str.c_str())) throw this->fail("appendToContent");
+}
+
+bool HybridXml::childContentMatches(const std::string& tagPath, const std::string& pattern, bool caseSensitive) {
+  this->beginCall();
+  return childContentMatches_impl(tagPath, pattern, caseSensitive);
+}
+bool HybridXml::childContentMatches_impl(const std::string& tagPath, const std::string& pattern, bool caseSensitive) {
+  rt::checkNoNul(tagPath, "tagPath");
+  rt::checkNoNul(pattern, "pattern");
+  return this->ck().ChildContentMatches(tagPath.c_str(), pattern.c_str(), caseSensitive);
+}
+
+std::string HybridXml::chilkatPath(const std::string& pathCmd) {
+  this->beginCall();
+  return chilkatPath_impl(pathCmd);
+}
+std::string HybridXml::chilkatPath_impl(const std::string& pathCmd) {
+  rt::checkNoNul(pathCmd, "pathCmd");
+  CkString _out;
+  if (!this->ck().ChilkatPath(pathCmd.c_str(), _out)) throw this->fail("chilkatPath");
+  return rt::stdString(_out);
+}
+
+void HybridXml::clear() {
+  this->beginCall();
+  clear_impl();
+}
+void HybridXml::clear_impl() {
+  this->ck().Clear();
+}
+
+bool HybridXml::contentMatches(const std::string& pattern, bool caseSensitive) {
+  this->beginCall();
+  return contentMatches_impl(pattern, caseSensitive);
+}
+bool HybridXml::contentMatches_impl(const std::string& pattern, bool caseSensitive) {
+  rt::checkNoNul(pattern, "pattern");
+  return this->ck().ContentMatches(pattern.c_str(), caseSensitive);
+}
+
+void HybridXml::copy(const std::shared_ptr<HybridXmlSpec>& node) {
+  this->beginCall();
+  copy_impl(node);
+}
+void HybridXml::copy_impl(const std::shared_ptr<HybridXmlSpec>& node) {
+  this->ck().Copy(rt::implOf<HybridXml>(node, "node").ck());
+}
+
+void HybridXml::copyRef(const std::shared_ptr<HybridXmlSpec>& copyFromNode) {
+  this->beginCall();
+  copyRef_impl(copyFromNode);
+}
+void HybridXml::copyRef_impl(const std::shared_ptr<HybridXmlSpec>& copyFromNode) {
+  this->ck().CopyRef(rt::implOf<HybridXml>(copyFromNode, "copyFromNode").ck());
+}
+
+std::string HybridXml::decodeEntities(const std::string& str) {
+  this->beginCall();
+  return decodeEntities_impl(str);
+}
+std::string HybridXml::decodeEntities_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  CkString _out;
+  if (!this->ck().DecodeEntities(str.c_str(), _out)) throw this->fail("decodeEntities");
+  return rt::stdString(_out);
+}
+
+void HybridXml::decryptContent(const std::string& password) {
+  this->beginCall();
+  decryptContent_impl(password);
+}
+void HybridXml::decryptContent_impl(const std::string& password) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().DecryptContent(password.c_str())) throw this->fail("decryptContent");
+}
+
+void HybridXml::encryptContent(const std::string& password) {
+  this->beginCall();
+  encryptContent_impl(password);
+}
+void HybridXml::encryptContent_impl(const std::string& password) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().EncryptContent(password.c_str())) throw this->fail("encryptContent");
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::extractChildByIndex(double index) {
+  this->beginCall();
+  return extractChildByIndex_impl(index);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::extractChildByIndex_impl(double index) {
+  CkXml* _r = this->ck().ExtractChildByIndex(rt::toInt(index, "index"));
+  if (!_r) throw this->fail("extractChildByIndex");
+  return std::make_shared<HybridXml>(_r);
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::extractChildByName(const std::string& tagPath, const std::string& attrName, const std::string& attrValue) {
+  this->beginCall();
+  return extractChildByName_impl(tagPath, attrName, attrValue);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::extractChildByName_impl(const std::string& tagPath, const std::string& attrName, const std::string& attrValue) {
+  rt::checkNoNul(tagPath, "tagPath");
+  rt::checkNoNul(attrName, "attrName");
+  rt::checkNoNul(attrValue, "attrValue");
+  CkXml* _r = this->ck().ExtractChildByName(tagPath.c_str(), attrName.c_str(), attrValue.c_str());
+  if (!_r) throw this->fail("extractChildByName");
+  return std::make_shared<HybridXml>(_r);
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::findChild(const std::string& tagPath) {
+  this->beginCall();
+  return findChild_impl(tagPath);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::findChild_impl(const std::string& tagPath) {
+  rt::checkNoNul(tagPath, "tagPath");
+  CkXml* _r = this->ck().FindChild(tagPath.c_str());
+  if (!_r) throw this->fail("findChild");
+  return std::make_shared<HybridXml>(_r);
+}
+
+void HybridXml::findChild2(const std::string& tagPath) {
+  this->beginCall();
+  findChild2_impl(tagPath);
+}
+void HybridXml::findChild2_impl(const std::string& tagPath) {
+  rt::checkNoNul(tagPath, "tagPath");
+  if (!this->ck().FindChild2(tagPath.c_str())) throw this->fail("findChild2");
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::findNextRecord(const std::string& tagPath, const std::string& contentPattern) {
+  this->beginCall();
+  return findNextRecord_impl(tagPath, contentPattern);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::findNextRecord_impl(const std::string& tagPath, const std::string& contentPattern) {
+  rt::checkNoNul(tagPath, "tagPath");
+  rt::checkNoNul(contentPattern, "contentPattern");
+  CkXml* _r = this->ck().FindNextRecord(tagPath.c_str(), contentPattern.c_str());
+  if (!_r) throw this->fail("findNextRecord");
+  return std::make_shared<HybridXml>(_r);
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::findOrAddNewChild(const std::string& tagPath) {
+  this->beginCall();
+  return findOrAddNewChild_impl(tagPath);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::findOrAddNewChild_impl(const std::string& tagPath) {
+  rt::checkNoNul(tagPath, "tagPath");
+  CkXml* _r = this->ck().FindOrAddNewChild(tagPath.c_str());
+  if (!_r) throw this->fail("findOrAddNewChild");
+  return std::make_shared<HybridXml>(_r);
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::firstChild() {
+  this->beginCall();
+  return firstChild_impl();
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::firstChild_impl() {
+  CkXml* _r = this->ck().FirstChild();
+  if (!_r) throw this->fail("firstChild");
+  return std::make_shared<HybridXml>(_r);
+}
+
+bool HybridXml::firstChild2() {
+  this->beginCall();
+  return firstChild2_impl();
+}
+bool HybridXml::firstChild2_impl() {
+  return this->ck().FirstChild2();
+}
+
+std::string HybridXml::getAttrValue(const std::string& name) {
+  this->beginCall();
+  return getAttrValue_impl(name);
+}
+std::string HybridXml::getAttrValue_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  CkString _out;
+  if (!this->ck().GetAttrValue(name.c_str(), _out)) throw this->fail("getAttrValue");
+  return rt::stdString(_out);
+}
+
+double HybridXml::getAttrValueInt(const std::string& name) {
+  this->beginCall();
+  return getAttrValueInt_impl(name);
+}
+double HybridXml::getAttrValueInt_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  return static_cast<double>(this->ck().GetAttrValueInt(name.c_str()));
+}
+
+std::string HybridXml::getAttributeName(double index) {
+  this->beginCall();
+  return getAttributeName_impl(index);
+}
+std::string HybridXml::getAttributeName_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetAttributeName(rt::toInt(index, "index"), _out)) throw this->fail("getAttributeName");
+  return rt::stdString(_out);
+}
+
+std::string HybridXml::getAttributeValue(double index) {
+  this->beginCall();
+  return getAttributeValue_impl(index);
+}
+std::string HybridXml::getAttributeValue_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetAttributeValue(rt::toInt(index, "index"), _out)) throw this->fail("getAttributeValue");
+  return rt::stdString(_out);
+}
+
+double HybridXml::getAttributeValueInt(double index) {
+  this->beginCall();
+  return getAttributeValueInt_impl(index);
+}
+double HybridXml::getAttributeValueInt_impl(double index) {
+  return static_cast<double>(this->ck().GetAttributeValueInt(rt::toInt(index, "index")));
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::getChild(double index) {
+  this->beginCall();
+  return getChild_impl(index);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::getChild_impl(double index) {
+  CkXml* _r = this->ck().GetChild(rt::toInt(index, "index"));
+  if (!_r) throw this->fail("getChild");
+  return std::make_shared<HybridXml>(_r);
+}
+
+void HybridXml::getChild2(double index) {
+  this->beginCall();
+  getChild2_impl(index);
+}
+void HybridXml::getChild2_impl(double index) {
+  if (!this->ck().GetChild2(rt::toInt(index, "index"))) throw this->fail("getChild2");
+}
+
+bool HybridXml::getChildBoolValue(const std::string& tagPath) {
+  this->beginCall();
+  return getChildBoolValue_impl(tagPath);
+}
+bool HybridXml::getChildBoolValue_impl(const std::string& tagPath) {
+  rt::checkNoNul(tagPath, "tagPath");
+  return this->ck().GetChildBoolValue(tagPath.c_str());
+}
+
+std::string HybridXml::getChildContent(const std::string& tagPath) {
+  this->beginCall();
+  return getChildContent_impl(tagPath);
+}
+std::string HybridXml::getChildContent_impl(const std::string& tagPath) {
+  rt::checkNoNul(tagPath, "tagPath");
+  CkString _out;
+  if (!this->ck().GetChildContent(tagPath.c_str(), _out)) throw this->fail("getChildContent");
+  return rt::stdString(_out);
+}
+
+std::string HybridXml::getChildContentByIndex(double index) {
+  this->beginCall();
+  return getChildContentByIndex_impl(index);
+}
+std::string HybridXml::getChildContentByIndex_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetChildContentByIndex(rt::toInt(index, "index"), _out)) throw this->fail("getChildContentByIndex");
+  return rt::stdString(_out);
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::getChildExact(const std::string& tag, const std::string& content) {
+  this->beginCall();
+  return getChildExact_impl(tag, content);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::getChildExact_impl(const std::string& tag, const std::string& content) {
+  rt::checkNoNul(tag, "tag");
+  rt::checkNoNul(content, "content");
+  CkXml* _r = this->ck().GetChildExact(tag.c_str(), content.c_str());
+  if (!_r) throw this->fail("getChildExact");
+  return std::make_shared<HybridXml>(_r);
+}
+
+double HybridXml::getChildIntValue(const std::string& tagPath) {
+  this->beginCall();
+  return getChildIntValue_impl(tagPath);
+}
+double HybridXml::getChildIntValue_impl(const std::string& tagPath) {
+  rt::checkNoNul(tagPath, "tagPath");
+  return static_cast<double>(this->ck().GetChildIntValue(tagPath.c_str()));
+}
+
+std::string HybridXml::getChildTag(double index) {
+  this->beginCall();
+  return getChildTag_impl(index);
+}
+std::string HybridXml::getChildTag_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetChildTag(rt::toInt(index, "index"), _out)) throw this->fail("getChildTag");
+  return rt::stdString(_out);
+}
+
+std::string HybridXml::getChildTagByIndex(double index) {
+  this->beginCall();
+  return getChildTagByIndex_impl(index);
+}
+std::string HybridXml::getChildTagByIndex_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetChildTagByIndex(rt::toInt(index, "index"), _out)) throw this->fail("getChildTagByIndex");
+  return rt::stdString(_out);
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::getChildWithAttr(const std::string& tagPath, const std::string& attrName, const std::string& attrValue) {
+  this->beginCall();
+  return getChildWithAttr_impl(tagPath, attrName, attrValue);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::getChildWithAttr_impl(const std::string& tagPath, const std::string& attrName, const std::string& attrValue) {
+  rt::checkNoNul(tagPath, "tagPath");
+  rt::checkNoNul(attrName, "attrName");
+  rt::checkNoNul(attrValue, "attrValue");
+  CkXml* _r = this->ck().GetChildWithAttr(tagPath.c_str(), attrName.c_str(), attrValue.c_str());
+  if (!_r) throw this->fail("getChildWithAttr");
+  return std::make_shared<HybridXml>(_r);
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::getChildWithContent(const std::string& content) {
+  this->beginCall();
+  return getChildWithContent_impl(content);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::getChildWithContent_impl(const std::string& content) {
+  rt::checkNoNul(content, "content");
+  CkXml* _r = this->ck().GetChildWithContent(content.c_str());
+  if (!_r) throw this->fail("getChildWithContent");
+  return std::make_shared<HybridXml>(_r);
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::getChildWithTag(const std::string& tagPath) {
+  this->beginCall();
+  return getChildWithTag_impl(tagPath);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::getChildWithTag_impl(const std::string& tagPath) {
+  rt::checkNoNul(tagPath, "tagPath");
+  CkXml* _r = this->ck().GetChildWithTag(tagPath.c_str());
+  if (!_r) throw this->fail("getChildWithTag");
+  return std::make_shared<HybridXml>(_r);
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::getNthChildWithTag(const std::string& tag, double n) {
+  this->beginCall();
+  return getNthChildWithTag_impl(tag, n);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::getNthChildWithTag_impl(const std::string& tag, double n) {
+  rt::checkNoNul(tag, "tag");
+  CkXml* _r = this->ck().GetNthChildWithTag(tag.c_str(), rt::toInt(n, "n"));
+  if (!_r) throw this->fail("getNthChildWithTag");
+  return std::make_shared<HybridXml>(_r);
+}
+
+void HybridXml::getNthChildWithTag2(const std::string& tag, double n) {
+  this->beginCall();
+  getNthChildWithTag2_impl(tag, n);
+}
+void HybridXml::getNthChildWithTag2_impl(const std::string& tag, double n) {
+  rt::checkNoNul(tag, "tag");
+  if (!this->ck().GetNthChildWithTag2(tag.c_str(), rt::toInt(n, "n"))) throw this->fail("getNthChildWithTag2");
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::getParent() {
+  this->beginCall();
+  return getParent_impl();
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::getParent_impl() {
+  CkXml* _r = this->ck().GetParent();
+  if (!_r) throw this->fail("getParent");
+  return std::make_shared<HybridXml>(_r);
+}
+
+void HybridXml::getParent2() {
+  this->beginCall();
+  getParent2_impl();
+}
+void HybridXml::getParent2_impl() {
+  if (!this->ck().GetParent2()) throw this->fail("getParent2");
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::getRoot() {
+  this->beginCall();
+  return getRoot_impl();
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::getRoot_impl() {
+  CkXml* _r = this->ck().GetRoot();
+  if (!_r) throw this->fail("getRoot");
+  return std::make_shared<HybridXml>(_r);
+}
+
+void HybridXml::getRoot2() {
+  this->beginCall();
+  getRoot2_impl();
+}
+void HybridXml::getRoot2_impl() {
+  this->ck().GetRoot2();
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::getSelf() {
+  this->beginCall();
+  return getSelf_impl();
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::getSelf_impl() {
+  CkXml* _r = this->ck().GetSelf();
+  if (!_r) throw this->fail("getSelf");
+  return std::make_shared<HybridXml>(_r);
+}
+
+std::string HybridXml::getXml() {
+  this->beginCall();
+  return getXml_impl();
+}
+std::string HybridXml::getXml_impl() {
+  CkString _out;
+  if (!this->ck().GetXml(_out)) throw this->fail("getXml");
+  return rt::stdString(_out);
+}
+
+bool HybridXml::hasAttrWithValue(const std::string& name, const std::string& value) {
+  this->beginCall();
+  return hasAttrWithValue_impl(name, value);
+}
+bool HybridXml::hasAttrWithValue_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  return this->ck().HasAttrWithValue(name.c_str(), value.c_str());
+}
+
+bool HybridXml::hasAttribute(const std::string& name) {
+  this->beginCall();
+  return hasAttribute_impl(name);
+}
+bool HybridXml::hasAttribute_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  return this->ck().HasAttribute(name.c_str());
+}
+
+bool HybridXml::hasChildWithContent(const std::string& content) {
+  this->beginCall();
+  return hasChildWithContent_impl(content);
+}
+bool HybridXml::hasChildWithContent_impl(const std::string& content) {
+  rt::checkNoNul(content, "content");
+  return this->ck().HasChildWithContent(content.c_str());
+}
+
+bool HybridXml::hasChildWithTag(const std::string& tagPath) {
+  this->beginCall();
+  return hasChildWithTag_impl(tagPath);
+}
+bool HybridXml::hasChildWithTag_impl(const std::string& tagPath) {
+  rt::checkNoNul(tagPath, "tagPath");
+  return this->ck().HasChildWithTag(tagPath.c_str());
+}
+
+bool HybridXml::hasChildWithTagAndContent(const std::string& tagPath, const std::string& content) {
+  this->beginCall();
+  return hasChildWithTagAndContent_impl(tagPath, content);
+}
+bool HybridXml::hasChildWithTagAndContent_impl(const std::string& tagPath, const std::string& content) {
+  rt::checkNoNul(tagPath, "tagPath");
+  rt::checkNoNul(content, "content");
+  return this->ck().HasChildWithTagAndContent(tagPath.c_str(), content.c_str());
+}
+
+void HybridXml::insertChildTreeAfter(double index, const std::shared_ptr<HybridXmlSpec>& tree) {
+  this->beginCall();
+  insertChildTreeAfter_impl(index, tree);
+}
+void HybridXml::insertChildTreeAfter_impl(double index, const std::shared_ptr<HybridXmlSpec>& tree) {
+  this->ck().InsertChildTreeAfter(rt::toInt(index, "index"), rt::implOf<HybridXml>(tree, "tree").ck());
+}
+
+void HybridXml::insertChildTreeBefore(double index, const std::shared_ptr<HybridXmlSpec>& tree) {
+  this->beginCall();
+  insertChildTreeBefore_impl(index, tree);
+}
+void HybridXml::insertChildTreeBefore_impl(double index, const std::shared_ptr<HybridXmlSpec>& tree) {
+  this->ck().InsertChildTreeBefore(rt::toInt(index, "index"), rt::implOf<HybridXml>(tree, "tree").ck());
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::lastChild() {
+  this->beginCall();
+  return lastChild_impl();
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::lastChild_impl() {
+  CkXml* _r = this->ck().LastChild();
+  if (!_r) throw this->fail("lastChild");
+  return std::make_shared<HybridXml>(_r);
+}
+
+void HybridXml::lastChild2() {
+  this->beginCall();
+  lastChild2_impl();
+}
+void HybridXml::lastChild2_impl() {
+  if (!this->ck().LastChild2()) throw this->fail("lastChild2");
+}
+
+void HybridXml::loadXml(const std::string& xmlData) {
+  this->beginCall();
+  loadXml_impl(xmlData);
+}
+void HybridXml::loadXml_impl(const std::string& xmlData) {
+  rt::checkNoNul(xmlData, "xmlData");
+  if (!this->ck().LoadXml(xmlData.c_str())) throw this->fail("loadXml");
+}
+
+void HybridXml::loadXml2(const std::string& xmlData, bool autoTrim) {
+  this->beginCall();
+  loadXml2_impl(xmlData, autoTrim);
+}
+void HybridXml::loadXml2_impl(const std::string& xmlData, bool autoTrim) {
+  rt::checkNoNul(xmlData, "xmlData");
+  if (!this->ck().LoadXml2(xmlData.c_str(), autoTrim)) throw this->fail("loadXml2");
+}
+
+void HybridXml::loadXmlFile(const std::string& fileName) {
+  this->beginCall();
+  loadXmlFile_impl(fileName);
+}
+void HybridXml::loadXmlFile_impl(const std::string& fileName) {
+  rt::checkNoNul(fileName, "fileName");
+  if (!this->ck().LoadXmlFile(fileName.c_str())) throw this->fail("loadXmlFile");
+}
+
+void HybridXml::loadXmlFile2(const std::string& fileName, bool autoTrim) {
+  this->beginCall();
+  loadXmlFile2_impl(fileName, autoTrim);
+}
+void HybridXml::loadXmlFile2_impl(const std::string& fileName, bool autoTrim) {
+  rt::checkNoNul(fileName, "fileName");
+  if (!this->ck().LoadXmlFile2(fileName.c_str(), autoTrim)) throw this->fail("loadXmlFile2");
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::newChild(const std::string& tagPath, const std::string& content) {
+  this->beginCall();
+  return newChild_impl(tagPath, content);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::newChild_impl(const std::string& tagPath, const std::string& content) {
+  rt::checkNoNul(tagPath, "tagPath");
+  rt::checkNoNul(content, "content");
+  CkXml* _r = this->ck().NewChild(tagPath.c_str(), content.c_str());
+  if (!_r) throw this->fail("newChild");
+  return std::make_shared<HybridXml>(_r);
+}
+
+void HybridXml::newChild2(const std::string& tagPath, const std::string& content) {
+  this->beginCall();
+  newChild2_impl(tagPath, content);
+}
+void HybridXml::newChild2_impl(const std::string& tagPath, const std::string& content) {
+  rt::checkNoNul(tagPath, "tagPath");
+  rt::checkNoNul(content, "content");
+  this->ck().NewChild2(tagPath.c_str(), content.c_str());
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::newChildAfter(double index, const std::string& tag, const std::string& content) {
+  this->beginCall();
+  return newChildAfter_impl(index, tag, content);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::newChildAfter_impl(double index, const std::string& tag, const std::string& content) {
+  rt::checkNoNul(tag, "tag");
+  rt::checkNoNul(content, "content");
+  CkXml* _r = this->ck().NewChildAfter(rt::toInt(index, "index"), tag.c_str(), content.c_str());
+  if (!_r) throw this->fail("newChildAfter");
+  return std::make_shared<HybridXml>(_r);
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::newChildBefore(double index, const std::string& tag, const std::string& content) {
+  this->beginCall();
+  return newChildBefore_impl(index, tag, content);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::newChildBefore_impl(double index, const std::string& tag, const std::string& content) {
+  rt::checkNoNul(tag, "tag");
+  rt::checkNoNul(content, "content");
+  CkXml* _r = this->ck().NewChildBefore(rt::toInt(index, "index"), tag.c_str(), content.c_str());
+  if (!_r) throw this->fail("newChildBefore");
+  return std::make_shared<HybridXml>(_r);
+}
+
+void HybridXml::newChildInt2(const std::string& tagPath, double value) {
+  this->beginCall();
+  newChildInt2_impl(tagPath, value);
+}
+void HybridXml::newChildInt2_impl(const std::string& tagPath, double value) {
+  rt::checkNoNul(tagPath, "tagPath");
+  this->ck().NewChildInt2(tagPath.c_str(), rt::toInt(value, "value"));
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::nextSibling() {
+  this->beginCall();
+  return nextSibling_impl();
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::nextSibling_impl() {
+  CkXml* _r = this->ck().NextSibling();
+  if (!_r) throw this->fail("nextSibling");
+  return std::make_shared<HybridXml>(_r);
+}
+
+bool HybridXml::nextSibling2() {
+  this->beginCall();
+  return nextSibling2_impl();
+}
+bool HybridXml::nextSibling2_impl() {
+  return this->ck().NextSibling2();
+}
+
+double HybridXml::numChildrenHavingTag(const std::string& tag) {
+  this->beginCall();
+  return numChildrenHavingTag_impl(tag);
+}
+double HybridXml::numChildrenHavingTag_impl(const std::string& tag) {
+  rt::checkNoNul(tag, "tag");
+  return static_cast<double>(this->ck().NumChildrenHavingTag(tag.c_str()));
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::previousSibling() {
+  this->beginCall();
+  return previousSibling_impl();
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::previousSibling_impl() {
+  CkXml* _r = this->ck().PreviousSibling();
+  if (!_r) throw this->fail("previousSibling");
+  return std::make_shared<HybridXml>(_r);
+}
+
+void HybridXml::previousSibling2() {
+  this->beginCall();
+  previousSibling2_impl();
+}
+void HybridXml::previousSibling2_impl() {
+  if (!this->ck().PreviousSibling2()) throw this->fail("previousSibling2");
+}
+
+void HybridXml::removeAllAttributes() {
+  this->beginCall();
+  removeAllAttributes_impl();
+}
+void HybridXml::removeAllAttributes_impl() {
+  if (!this->ck().RemoveAllAttributes()) throw this->fail("removeAllAttributes");
+}
+
+void HybridXml::removeAllChildren() {
+  this->beginCall();
+  removeAllChildren_impl();
+}
+void HybridXml::removeAllChildren_impl() {
+  this->ck().RemoveAllChildren();
+}
+
+void HybridXml::removeAttribute(const std::string& name) {
+  this->beginCall();
+  removeAttribute_impl(name);
+}
+void HybridXml::removeAttribute_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().RemoveAttribute(name.c_str())) throw this->fail("removeAttribute");
+}
+
+void HybridXml::removeChild(const std::string& tagPath) {
+  this->beginCall();
+  removeChild_impl(tagPath);
+}
+void HybridXml::removeChild_impl(const std::string& tagPath) {
+  rt::checkNoNul(tagPath, "tagPath");
+  this->ck().RemoveChild(tagPath.c_str());
+}
+
+void HybridXml::removeChildByIndex(double index) {
+  this->beginCall();
+  removeChildByIndex_impl(index);
+}
+void HybridXml::removeChildByIndex_impl(double index) {
+  this->ck().RemoveChildByIndex(rt::toInt(index, "index"));
+}
+
+void HybridXml::removeChildWithContent(const std::string& content) {
+  this->beginCall();
+  removeChildWithContent_impl(content);
+}
+void HybridXml::removeChildWithContent_impl(const std::string& content) {
+  rt::checkNoNul(content, "content");
+  this->ck().RemoveChildWithContent(content.c_str());
+}
+
+void HybridXml::removeFromTree() {
+  this->beginCall();
+  removeFromTree_impl();
+}
+void HybridXml::removeFromTree_impl() {
+  this->ck().RemoveFromTree();
+}
+
+void HybridXml::saveBinaryContent(const std::string& filename, bool unzipFlag, bool decryptFlag, const std::string& password) {
+  this->beginCall();
+  saveBinaryContent_impl(filename, unzipFlag, decryptFlag, password);
+}
+void HybridXml::saveBinaryContent_impl(const std::string& filename, bool unzipFlag, bool decryptFlag, const std::string& password) {
+  rt::checkNoNul(filename, "filename");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().SaveBinaryContent(filename.c_str(), unzipFlag, decryptFlag, password.c_str())) throw this->fail("saveBinaryContent");
+}
+
+void HybridXml::saveXml(const std::string& fileName) {
+  this->beginCall();
+  saveXml_impl(fileName);
+}
+void HybridXml::saveXml_impl(const std::string& fileName) {
+  rt::checkNoNul(fileName, "fileName");
+  if (!this->ck().SaveXml(fileName.c_str())) throw this->fail("saveXml");
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::searchAllForContent(const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  this->beginCall();
+  return searchAllForContent_impl(contentPattern, after);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::searchAllForContent_impl(const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  CkXml* _after = (after.has_value() && *after) ? &rt::implOf<HybridXml>(*after, "after").ck() : nullptr;
+  rt::checkNoNul(contentPattern, "contentPattern");
+  CkXml* _r = this->ck().SearchAllForContent(_after, contentPattern.c_str());
+  if (!_r) throw this->fail("searchAllForContent");
+  return std::make_shared<HybridXml>(_r);
+}
+
+void HybridXml::searchAllForContent2(const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  this->beginCall();
+  searchAllForContent2_impl(contentPattern, after);
+}
+void HybridXml::searchAllForContent2_impl(const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  CkXml* _after = (after.has_value() && *after) ? &rt::implOf<HybridXml>(*after, "after").ck() : nullptr;
+  rt::checkNoNul(contentPattern, "contentPattern");
+  if (!this->ck().SearchAllForContent2(_after, contentPattern.c_str())) throw this->fail("searchAllForContent2");
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::searchForAttribute(const std::string& tag, const std::string& attr, const std::string& valuePattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  this->beginCall();
+  return searchForAttribute_impl(tag, attr, valuePattern, after);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::searchForAttribute_impl(const std::string& tag, const std::string& attr, const std::string& valuePattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  CkXml* _after = (after.has_value() && *after) ? &rt::implOf<HybridXml>(*after, "after").ck() : nullptr;
+  rt::checkNoNul(tag, "tag");
+  rt::checkNoNul(attr, "attr");
+  rt::checkNoNul(valuePattern, "valuePattern");
+  CkXml* _r = this->ck().SearchForAttribute(_after, tag.c_str(), attr.c_str(), valuePattern.c_str());
+  if (!_r) throw this->fail("searchForAttribute");
+  return std::make_shared<HybridXml>(_r);
+}
+
+void HybridXml::searchForAttribute2(const std::string& tag, const std::string& attr, const std::string& valuePattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  this->beginCall();
+  searchForAttribute2_impl(tag, attr, valuePattern, after);
+}
+void HybridXml::searchForAttribute2_impl(const std::string& tag, const std::string& attr, const std::string& valuePattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  CkXml* _after = (after.has_value() && *after) ? &rt::implOf<HybridXml>(*after, "after").ck() : nullptr;
+  rt::checkNoNul(tag, "tag");
+  rt::checkNoNul(attr, "attr");
+  rt::checkNoNul(valuePattern, "valuePattern");
+  if (!this->ck().SearchForAttribute2(_after, tag.c_str(), attr.c_str(), valuePattern.c_str())) throw this->fail("searchForAttribute2");
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::searchForContent(const std::string& tag, const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  this->beginCall();
+  return searchForContent_impl(tag, contentPattern, after);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::searchForContent_impl(const std::string& tag, const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  CkXml* _after = (after.has_value() && *after) ? &rt::implOf<HybridXml>(*after, "after").ck() : nullptr;
+  rt::checkNoNul(tag, "tag");
+  rt::checkNoNul(contentPattern, "contentPattern");
+  CkXml* _r = this->ck().SearchForContent(_after, tag.c_str(), contentPattern.c_str());
+  if (!_r) throw this->fail("searchForContent");
+  return std::make_shared<HybridXml>(_r);
+}
+
+void HybridXml::searchForContent2(const std::string& tag, const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  this->beginCall();
+  searchForContent2_impl(tag, contentPattern, after);
+}
+void HybridXml::searchForContent2_impl(const std::string& tag, const std::string& contentPattern, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  CkXml* _after = (after.has_value() && *after) ? &rt::implOf<HybridXml>(*after, "after").ck() : nullptr;
+  rt::checkNoNul(tag, "tag");
+  rt::checkNoNul(contentPattern, "contentPattern");
+  if (!this->ck().SearchForContent2(_after, tag.c_str(), contentPattern.c_str())) throw this->fail("searchForContent2");
+}
+
+std::shared_ptr<HybridXmlSpec> HybridXml::searchForTag(const std::string& tag, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  this->beginCall();
+  return searchForTag_impl(tag, after);
+}
+std::shared_ptr<HybridXmlSpec> HybridXml::searchForTag_impl(const std::string& tag, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  CkXml* _after = (after.has_value() && *after) ? &rt::implOf<HybridXml>(*after, "after").ck() : nullptr;
+  rt::checkNoNul(tag, "tag");
+  CkXml* _r = this->ck().SearchForTag(_after, tag.c_str());
+  if (!_r) throw this->fail("searchForTag");
+  return std::make_shared<HybridXml>(_r);
+}
+
+void HybridXml::searchForTag2(const std::string& tag, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  this->beginCall();
+  searchForTag2_impl(tag, after);
+}
+void HybridXml::searchForTag2_impl(const std::string& tag, const std::optional<std::shared_ptr<HybridXmlSpec>>& after) {
+  CkXml* _after = (after.has_value() && *after) ? &rt::implOf<HybridXml>(*after, "after").ck() : nullptr;
+  rt::checkNoNul(tag, "tag");
+  if (!this->ck().SearchForTag2(_after, tag.c_str())) throw this->fail("searchForTag2");
+}
+
+void HybridXml::setBinaryContentFromFile(const std::string& filename, bool zipFlag, bool encryptFlag, const std::string& password) {
+  this->beginCall();
+  setBinaryContentFromFile_impl(filename, zipFlag, encryptFlag, password);
+}
+void HybridXml::setBinaryContentFromFile_impl(const std::string& filename, bool zipFlag, bool encryptFlag, const std::string& password) {
+  rt::checkNoNul(filename, "filename");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().SetBinaryContentFromFile(filename.c_str(), zipFlag, encryptFlag, password.c_str())) throw this->fail("setBinaryContentFromFile");
+}
+
+void HybridXml::sortByAttribute(const std::string& attrName, bool ascending) {
+  this->beginCall();
+  sortByAttribute_impl(attrName, ascending);
+}
+void HybridXml::sortByAttribute_impl(const std::string& attrName, bool ascending) {
+  rt::checkNoNul(attrName, "attrName");
+  this->ck().SortByAttribute(attrName.c_str(), ascending);
+}
+
+void HybridXml::sortByAttributeInt(const std::string& attrName, bool ascending) {
+  this->beginCall();
+  sortByAttributeInt_impl(attrName, ascending);
+}
+void HybridXml::sortByAttributeInt_impl(const std::string& attrName, bool ascending) {
+  rt::checkNoNul(attrName, "attrName");
+  this->ck().SortByAttributeInt(attrName.c_str(), ascending);
+}
+
+void HybridXml::sortByContent(bool ascending) {
+  this->beginCall();
+  sortByContent_impl(ascending);
+}
+void HybridXml::sortByContent_impl(bool ascending) {
+  this->ck().SortByContent(ascending);
+}
+
+void HybridXml::sortByTag(bool ascending) {
+  this->beginCall();
+  sortByTag_impl(ascending);
+}
+void HybridXml::sortByTag_impl(bool ascending) {
+  this->ck().SortByTag(ascending);
+}
+
+void HybridXml::sortRecordsByAttribute(const std::string& sortTag, const std::string& attrName, bool ascending) {
+  this->beginCall();
+  sortRecordsByAttribute_impl(sortTag, attrName, ascending);
+}
+void HybridXml::sortRecordsByAttribute_impl(const std::string& sortTag, const std::string& attrName, bool ascending) {
+  rt::checkNoNul(sortTag, "sortTag");
+  rt::checkNoNul(attrName, "attrName");
+  this->ck().SortRecordsByAttribute(sortTag.c_str(), attrName.c_str(), ascending);
+}
+
+void HybridXml::sortRecordsByContent(const std::string& sortTag, bool ascending) {
+  this->beginCall();
+  sortRecordsByContent_impl(sortTag, ascending);
+}
+void HybridXml::sortRecordsByContent_impl(const std::string& sortTag, bool ascending) {
+  rt::checkNoNul(sortTag, "sortTag");
+  this->ck().SortRecordsByContent(sortTag.c_str(), ascending);
+}
+
+void HybridXml::sortRecordsByContentInt(const std::string& sortTag, bool ascending) {
+  this->beginCall();
+  sortRecordsByContentInt_impl(sortTag, ascending);
+}
+void HybridXml::sortRecordsByContentInt_impl(const std::string& sortTag, bool ascending) {
+  rt::checkNoNul(sortTag, "sortTag");
+  this->ck().SortRecordsByContentInt(sortTag.c_str(), ascending);
+}
+
+void HybridXml::swapNode(const std::shared_ptr<HybridXmlSpec>& node) {
+  this->beginCall();
+  swapNode_impl(node);
+}
+void HybridXml::swapNode_impl(const std::shared_ptr<HybridXmlSpec>& node) {
+  if (!this->ck().SwapNode(rt::implOf<HybridXml>(node, "node").ck())) throw this->fail("swapNode");
+}
+
+void HybridXml::swapTree(const std::shared_ptr<HybridXmlSpec>& tree) {
+  this->beginCall();
+  swapTree_impl(tree);
+}
+void HybridXml::swapTree_impl(const std::shared_ptr<HybridXmlSpec>& tree) {
+  if (!this->ck().SwapTree(rt::implOf<HybridXml>(tree, "tree").ck())) throw this->fail("swapTree");
+}
+
+std::string HybridXml::tagContent(const std::string& tagName) {
+  this->beginCall();
+  return tagContent_impl(tagName);
+}
+std::string HybridXml::tagContent_impl(const std::string& tagName) {
+  rt::checkNoNul(tagName, "tagName");
+  CkString _out;
+  if (!this->ck().TagContent(tagName.c_str(), _out)) throw this->fail("tagContent");
+  return rt::stdString(_out);
+}
+
+bool HybridXml::tagEquals(const std::string& tag) {
+  this->beginCall();
+  return tagEquals_impl(tag);
+}
+bool HybridXml::tagEquals_impl(const std::string& tag) {
+  rt::checkNoNul(tag, "tag");
+  return this->ck().TagEquals(tag.c_str());
+}
+
+void HybridXml::unzipContent() {
+  this->beginCall();
+  unzipContent_impl();
+}
+void HybridXml::unzipContent_impl() {
+  if (!this->ck().UnzipContent()) throw this->fail("unzipContent");
+}
+
+void HybridXml::unzipTree() {
+  this->beginCall();
+  unzipTree_impl();
+}
+void HybridXml::unzipTree_impl() {
+  if (!this->ck().UnzipTree()) throw this->fail("unzipTree");
+}
+
+void HybridXml::updateAttribute(const std::string& attrName, const std::string& attrValue) {
+  this->beginCall();
+  updateAttribute_impl(attrName, attrValue);
+}
+void HybridXml::updateAttribute_impl(const std::string& attrName, const std::string& attrValue) {
+  rt::checkNoNul(attrName, "attrName");
+  rt::checkNoNul(attrValue, "attrValue");
+  if (!this->ck().UpdateAttribute(attrName.c_str(), attrValue.c_str())) throw this->fail("updateAttribute");
+}
+
+void HybridXml::updateAttributeInt(const std::string& attrName, double value) {
+  this->beginCall();
+  updateAttributeInt_impl(attrName, value);
+}
+void HybridXml::updateAttributeInt_impl(const std::string& attrName, double value) {
+  rt::checkNoNul(attrName, "attrName");
+  if (!this->ck().UpdateAttributeInt(attrName.c_str(), rt::toInt(value, "value"))) throw this->fail("updateAttributeInt");
+}
+
+void HybridXml::updateChildContent(const std::string& tagPath, const std::string& value) {
+  this->beginCall();
+  updateChildContent_impl(tagPath, value);
+}
+void HybridXml::updateChildContent_impl(const std::string& tagPath, const std::string& value) {
+  rt::checkNoNul(tagPath, "tagPath");
+  rt::checkNoNul(value, "value");
+  this->ck().UpdateChildContent(tagPath.c_str(), value.c_str());
+}
+
+void HybridXml::updateChildContentInt(const std::string& tagPath, double value) {
+  this->beginCall();
+  updateChildContentInt_impl(tagPath, value);
+}
+void HybridXml::updateChildContentInt_impl(const std::string& tagPath, double value) {
+  rt::checkNoNul(tagPath, "tagPath");
+  this->ck().UpdateChildContentInt(tagPath.c_str(), rt::toInt(value, "value"));
+}
+
+void HybridXml::zipContent() {
+  this->beginCall();
+  zipContent_impl();
+}
+void HybridXml::zipContent_impl() {
+  if (!this->ck().ZipContent()) throw this->fail("zipContent");
+}
+
+void HybridXml::zipTree() {
+  this->beginCall();
+  zipTree_impl();
+}
+void HybridXml::zipTree_impl() {
+  if (!this->ck().ZipTree()) throw this->fail("zipTree");
+}
+
+void HybridXml::loadSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool autoTrim) {
+  this->beginCall();
+  loadSb_impl(sb, autoTrim);
+}
+void HybridXml::loadSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool autoTrim) {
+  if (!this->ck().LoadSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck(), autoTrim)) throw this->fail("loadSb");
+}
+
+void HybridXml::getXmlSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  getXmlSb_impl(sb);
+}
+void HybridXml::getXmlSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().GetXmlSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("getXmlSb");
+}
+
+double HybridXml::numChildrenAt(const std::string& tagPath) {
+  this->beginCall();
+  return numChildrenAt_impl(tagPath);
+}
+double HybridXml::numChildrenAt_impl(const std::string& tagPath) {
+  rt::checkNoNul(tagPath, "tagPath");
+  return static_cast<double>(this->ck().NumChildrenAt(tagPath.c_str()));
+}
+
+void HybridXml::updateAt(const std::string& tagPath, bool autoCreate, const std::string& value) {
+  this->beginCall();
+  updateAt_impl(tagPath, autoCreate, value);
+}
+void HybridXml::updateAt_impl(const std::string& tagPath, bool autoCreate, const std::string& value) {
+  rt::checkNoNul(tagPath, "tagPath");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().UpdateAt(tagPath.c_str(), autoCreate, value.c_str())) throw this->fail("updateAt");
+}
+
+void HybridXml::updateAttrAt(const std::string& tagPath, bool autoCreate, const std::string& attrName, const std::string& attrValue) {
+  this->beginCall();
+  updateAttrAt_impl(tagPath, autoCreate, attrName, attrValue);
+}
+void HybridXml::updateAttrAt_impl(const std::string& tagPath, bool autoCreate, const std::string& attrName, const std::string& attrValue) {
+  rt::checkNoNul(tagPath, "tagPath");
+  rt::checkNoNul(attrName, "attrName");
+  rt::checkNoNul(attrValue, "attrValue");
+  if (!this->ck().UpdateAttrAt(tagPath.c_str(), autoCreate, attrName.c_str(), attrValue.c_str())) throw this->fail("updateAttrAt");
+}
+
+void HybridXml::getChildContentSb(const std::string& tagPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  getChildContentSb_impl(tagPath, sb);
+}
+void HybridXml::getChildContentSb_impl(const std::string& tagPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  rt::checkNoNul(tagPath, "tagPath");
+  if (!this->ck().GetChildContentSb(tagPath.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("getChildContentSb");
+}
+
+double HybridXml::tagIndex(const std::string& tagPath) {
+  this->beginCall();
+  return tagIndex_impl(tagPath);
+}
+double HybridXml::tagIndex_impl(const std::string& tagPath) {
+  rt::checkNoNul(tagPath, "tagPath");
+  return static_cast<double>(this->ck().TagIndex(tagPath.c_str()));
+}
+
+bool HybridXml::tagNsEquals(const std::string& ns) {
+  this->beginCall();
+  return tagNsEquals_impl(ns);
+}
+bool HybridXml::tagNsEquals_impl(const std::string& ns) {
+  rt::checkNoNul(ns, "ns");
+  return this->ck().TagNsEquals(ns.c_str());
+}
+
+bool HybridXml::tagUnpEquals(const std::string& unprefixedTag) {
+  this->beginCall();
+  return tagUnpEquals_impl(unprefixedTag);
+}
+bool HybridXml::tagUnpEquals_impl(const std::string& unprefixedTag) {
+  rt::checkNoNul(unprefixedTag, "unprefixedTag");
+  return this->ck().TagUnpEquals(unprefixedTag.c_str());
+}
+
+std::string HybridXml::getChildAttrValue(const std::string& tagPath, const std::string& attrName) {
+  this->beginCall();
+  return getChildAttrValue_impl(tagPath, attrName);
+}
+std::string HybridXml::getChildAttrValue_impl(const std::string& tagPath, const std::string& attrName) {
+  rt::checkNoNul(tagPath, "tagPath");
+  rt::checkNoNul(attrName, "attrName");
+  CkString _out;
+  if (!this->ck().GetChildAttrValue(tagPath.c_str(), attrName.c_str(), _out)) throw this->fail("getChildAttrValue");
+  return rt::stdString(_out);
+}
+
+double HybridXml::removeStyleSheet(const std::string& attrName, const std::string& attrValue) {
+  this->beginCall();
+  return removeStyleSheet_impl(attrName, attrValue);
+}
+double HybridXml::removeStyleSheet_impl(const std::string& attrName, const std::string& attrValue) {
+  rt::checkNoNul(attrName, "attrName");
+  rt::checkNoNul(attrValue, "attrValue");
+  return static_cast<double>(this->ck().RemoveStyleSheet(attrName.c_str(), attrValue.c_str()));
+}
+
+double HybridXml::pruneAttribute(const std::string& attrName) {
+  this->beginCall();
+  return pruneAttribute_impl(attrName);
+}
+double HybridXml::pruneAttribute_impl(const std::string& attrName) {
+  rt::checkNoNul(attrName, "attrName");
+  return static_cast<double>(this->ck().PruneAttribute(attrName.c_str()));
+}
+
+double HybridXml::pruneTag(const std::string& tag) {
+  this->beginCall();
+  return pruneTag_impl(tag);
+}
+double HybridXml::pruneTag_impl(const std::string& tag) {
+  rt::checkNoNul(tag, "tag");
+  return static_cast<double>(this->ck().PruneTag(tag.c_str()));
+}
+
+void HybridXml::scrub(const std::string& directives) {
+  this->beginCall();
+  scrub_impl(directives);
+}
+void HybridXml::scrub_impl(const std::string& directives) {
+  rt::checkNoNul(directives, "directives");
+  this->ck().Scrub(directives.c_str());
+}
+
+void HybridXml::loadBd(const std::shared_ptr<HybridBinDataSpec>& bd, bool autoTrim) {
+  this->beginCall();
+  loadBd_impl(bd, autoTrim);
+}
+void HybridXml::loadBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, bool autoTrim) {
+  if (!this->ck().LoadBd(rt::implOf<HybridBinData>(bd, "bd").ck(), autoTrim)) throw this->fail("loadBd");
+}
+
+void HybridXml::getXmlBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  getXmlBd_impl(bd);
+}
+void HybridXml::getXmlBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().GetXmlBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("getXmlBd");
+}
+
+bool HybridXml::nextInTraversal2(const std::shared_ptr<HybridStringBuilderSpec>& sbState) {
+  this->beginCall();
+  return nextInTraversal2_impl(sbState);
+}
+bool HybridXml::nextInTraversal2_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbState) {
+  return this->ck().NextInTraversal2(rt::implOf<HybridStringBuilder>(sbState, "sbState").ck());
+}
+
+void HybridXml::setBinaryContentBd(const std::shared_ptr<HybridBinDataSpec>& data, bool zipFlag, bool encryptFlag, const std::string& password) {
+  this->beginCall();
+  setBinaryContentBd_impl(data, zipFlag, encryptFlag, password);
+}
+void HybridXml::setBinaryContentBd_impl(const std::shared_ptr<HybridBinDataSpec>& data, bool zipFlag, bool encryptFlag, const std::string& password) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().SetBinaryContentBd(rt::implOf<HybridBinData>(data, "data").ck(), zipFlag, encryptFlag, password.c_str())) throw this->fail("setBinaryContentBd");
+}
+
+void HybridXml::getChildWithTag2(const std::string& tagPath) {
+  this->beginCall();
+  getChildWithTag2_impl(tagPath);
+}
+void HybridXml::getChildWithTag2_impl(const std::string& tagPath) {
+  rt::checkNoNul(tagPath, "tagPath");
+  if (!this->ck().GetChildWithTag2(tagPath.c_str())) throw this->fail("getChildWithTag2");
+}
+
+} // namespace margelo::nitro::chilkat