@chilkat/react-native 11.6.1

package/cpp/HybridHashtable.cpp

@@ -0,0 +1,211 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridHashtable.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridStringTable.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridHashtable::HybridHashtable()
+    : HybridObject(HybridHashtableSpec::TAG), ChilkatObject<CkHashtable>("Hashtable", CkHashtable::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridHashtable::HybridHashtable(CkHashtable* owned)
+    : HybridObject(HybridHashtableSpec::TAG), ChilkatObject<CkHashtable>("Hashtable", owned) {
+  init();
+}
+
+void HybridHashtable::init() {
+}
+
+void HybridHashtable::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridHashtable::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHashtable::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHashtable::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHashtable::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHashtable::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridHashtable::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridHashtable::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridHashtable::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridHashtable::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridHashtable::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridHashtable::getCount() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Count());
+}
+
+// ---- Methods ----
+
+void HybridHashtable::addInt(const std::string& key, double value) {
+  this->beginCall();
+  addInt_impl(key, value);
+}
+void HybridHashtable::addInt_impl(const std::string& key, double value) {
+  rt::checkNoNul(key, "key");
+  if (!this->ck().AddInt(key.c_str(), rt::toInt(value, "value"))) throw this->fail("addInt");
+}
+
+void HybridHashtable::addStr(const std::string& key, const std::string& value) {
+  this->beginCall();
+  addStr_impl(key, value);
+}
+void HybridHashtable::addStr_impl(const std::string& key, const std::string& value) {
+  rt::checkNoNul(key, "key");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().AddStr(key.c_str(), value.c_str())) throw this->fail("addStr");
+}
+
+void HybridHashtable::clear() {
+  this->beginCall();
+  clear_impl();
+}
+void HybridHashtable::clear_impl() {
+  this->ck().Clear();
+}
+
+void HybridHashtable::clearWithNewCapacity(double capacity) {
+  this->beginCall();
+  clearWithNewCapacity_impl(capacity);
+}
+void HybridHashtable::clearWithNewCapacity_impl(double capacity) {
+  if (!this->ck().ClearWithNewCapacity(rt::toInt(capacity, "capacity"))) throw this->fail("clearWithNewCapacity");
+}
+
+bool HybridHashtable::contains(const std::string& key) {
+  this->beginCall();
+  return contains_impl(key);
+}
+bool HybridHashtable::contains_impl(const std::string& key) {
+  rt::checkNoNul(key, "key");
+  return this->ck().Contains(key.c_str());
+}
+
+double HybridHashtable::lookupInt(const std::string& key) {
+  this->beginCall();
+  return lookupInt_impl(key);
+}
+double HybridHashtable::lookupInt_impl(const std::string& key) {
+  rt::checkNoNul(key, "key");
+  return static_cast<double>(this->ck().LookupInt(key.c_str()));
+}
+
+std::string HybridHashtable::lookupStr(const std::string& key) {
+  this->beginCall();
+  return lookupStr_impl(key);
+}
+std::string HybridHashtable::lookupStr_impl(const std::string& key) {
+  rt::checkNoNul(key, "key");
+  CkString _out;
+  if (!this->ck().LookupStr(key.c_str(), _out)) throw this->fail("lookupStr");
+  return rt::stdString(_out);
+}
+
+void HybridHashtable::remove(const std::string& key) {
+  this->beginCall();
+  remove_impl(key);
+}
+void HybridHashtable::remove_impl(const std::string& key) {
+  rt::checkNoNul(key, "key");
+  if (!this->ck().Remove(key.c_str())) throw this->fail("remove");
+}
+
+void HybridHashtable::getKeys(const std::shared_ptr<HybridStringTableSpec>& strTable) {
+  this->beginCall();
+  getKeys_impl(strTable);
+}
+void HybridHashtable::getKeys_impl(const std::shared_ptr<HybridStringTableSpec>& strTable) {
+  if (!this->ck().GetKeys(rt::implOf<HybridStringTable>(strTable, "strTable").ck())) throw this->fail("getKeys");
+}
+
+void HybridHashtable::addQueryParams(const std::string& queryParams) {
+  this->beginCall();
+  addQueryParams_impl(queryParams);
+}
+void HybridHashtable::addQueryParams_impl(const std::string& queryParams) {
+  rt::checkNoNul(queryParams, "queryParams");
+  if (!this->ck().AddQueryParams(queryParams.c_str())) throw this->fail("addQueryParams");
+}
+
+void HybridHashtable::toXmlSb(const std::shared_ptr<HybridStringBuilderSpec>& sbXml) {
+  this->beginCall();
+  toXmlSb_impl(sbXml);
+}
+void HybridHashtable::toXmlSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbXml) {
+  if (!this->ck().ToXmlSb(rt::implOf<HybridStringBuilder>(sbXml, "sbXml").ck())) throw this->fail("toXmlSb");
+}
+
+void HybridHashtable::addFromXmlSb(const std::shared_ptr<HybridStringBuilderSpec>& sbXml) {
+  this->beginCall();
+  addFromXmlSb_impl(sbXml);
+}
+void HybridHashtable::addFromXmlSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbXml) {
+  if (!this->ck().AddFromXmlSb(rt::implOf<HybridStringBuilder>(sbXml, "sbXml").ck())) throw this->fail("addFromXmlSb");
+}
+
+bool HybridHashtable::containsIntKey(double key) {
+  this->beginCall();
+  return containsIntKey_impl(key);
+}
+bool HybridHashtable::containsIntKey_impl(double key) {
+  return this->ck().ContainsIntKey(rt::toInt(key, "key"));
+}
+
+std::string HybridHashtable::toQueryString() {
+  this->beginCall();
+  return toQueryString_impl();
+}
+std::string HybridHashtable::toQueryString_impl() {
+  CkString _out;
+  if (!this->ck().ToQueryString(_out)) throw this->fail("toQueryString");
+  return rt::stdString(_out);
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridHashtable.hpp

@@ -0,0 +1,64 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Hashtable: the Nitro HybridObject over Chilkat's CkHashtable (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridHashtableSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkHashtable.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridHashtable final : public HybridHashtableSpec, public ChilkatObject<CkHashtable> {
+public:
+  HybridHashtable();                                  // `new Hashtable()` from JS
+  explicit HybridHashtable(CkHashtable* 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;
+  double getCount() override;
+
+  // ---- Methods ----
+  void addInt(const std::string& key, double value) override;
+  void addStr(const std::string& key, const std::string& value) override;
+  void clear() override;
+  void clearWithNewCapacity(double capacity) override;
+  bool contains(const std::string& key) override;
+  double lookupInt(const std::string& key) override;
+  std::string lookupStr(const std::string& key) override;
+  void remove(const std::string& key) override;
+  void getKeys(const std::shared_ptr<HybridStringTableSpec>& strTable) override;
+  void addQueryParams(const std::string& queryParams) override;
+  void toXmlSb(const std::shared_ptr<HybridStringBuilderSpec>& sbXml) override;
+  void addFromXmlSb(const std::shared_ptr<HybridStringBuilderSpec>& sbXml) override;
+  bool containsIntKey(double key) override;
+  std::string toQueryString() override;
+
+private:
+  void init();
+  void addInt_impl(const std::string& key, double value);
+  void addStr_impl(const std::string& key, const std::string& value);
+  void clear_impl();
+  void clearWithNewCapacity_impl(double capacity);
+  bool contains_impl(const std::string& key);
+  double lookupInt_impl(const std::string& key);
+  std::string lookupStr_impl(const std::string& key);
+  void remove_impl(const std::string& key);
+  void getKeys_impl(const std::shared_ptr<HybridStringTableSpec>& strTable);
+  void addQueryParams_impl(const std::string& queryParams);
+  void toXmlSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbXml);
+  void addFromXmlSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbXml);
+  bool containsIntKey_impl(double key);
+  std::string toQueryString_impl();
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridHtmlToText.cpp

@@ -0,0 +1,136 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridHtmlToText.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridHtmlToText::HybridHtmlToText()
+    : HybridObject(HybridHtmlToTextSpec::TAG), ChilkatObject<CkHtmlToText>("HtmlToText", CkHtmlToText::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridHtmlToText::HybridHtmlToText(CkHtmlToText* owned)
+    : HybridObject(HybridHtmlToTextSpec::TAG), ChilkatObject<CkHtmlToText>("HtmlToText", owned) {
+  init();
+}
+
+void HybridHtmlToText::init() {
+}
+
+void HybridHtmlToText::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridHtmlToText::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHtmlToText::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHtmlToText::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHtmlToText::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHtmlToText::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridHtmlToText::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridHtmlToText::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridHtmlToText::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridHtmlToText::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridHtmlToText::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridHtmlToText::getDecodeHtmlEntities() {
+  this->beginCall();
+  return this->ck().get_DecodeHtmlEntities();
+}
+void HybridHtmlToText::setDecodeHtmlEntities(bool value) {
+  this->beginCall();
+  this->ck().put_DecodeHtmlEntities(value);
+}
+double HybridHtmlToText::getRightMargin() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_RightMargin());
+}
+void HybridHtmlToText::setRightMargin(double value) {
+  this->beginCall();
+  this->ck().put_RightMargin(rt::toInt(value, "rightMargin"));
+}
+bool HybridHtmlToText::getSuppressLinks() {
+  this->beginCall();
+  return this->ck().get_SuppressLinks();
+}
+void HybridHtmlToText::setSuppressLinks(bool value) {
+  this->beginCall();
+  this->ck().put_SuppressLinks(value);
+}
+std::string HybridHtmlToText::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridHtmlToText::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+std::string HybridHtmlToText::toText(const std::string& html) {
+  this->beginCall();
+  return toText_impl(html);
+}
+std::string HybridHtmlToText::toText_impl(const std::string& html) {
+  rt::checkNoNul(html, "html");
+  CkString _out;
+  if (!this->ck().ToText(html.c_str(), _out)) throw this->fail("toText");
+  return rt::stdString(_out);
+}
+
+void HybridHtmlToText::toTextSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  toTextSb_impl(sb);
+}
+void HybridHtmlToText::toTextSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().ToTextSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("toTextSb");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridHtmlToText.hpp

@@ -0,0 +1,47 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// HtmlToText: the Nitro HybridObject over Chilkat's CkHtmlToText (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridHtmlToTextSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkHtmlToText.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridHtmlToText final : public HybridHtmlToTextSpec, public ChilkatObject<CkHtmlToText> {
+public:
+  HybridHtmlToText();                                  // `new HtmlToText()` from JS
+  explicit HybridHtmlToText(CkHtmlToText* 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 getDecodeHtmlEntities() override;
+  void setDecodeHtmlEntities(bool value) override;
+  double getRightMargin() override;
+  void setRightMargin(double value) override;
+  bool getSuppressLinks() override;
+  void setSuppressLinks(bool value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+
+  // ---- Methods ----
+  std::string toText(const std::string& html) override;
+  void toTextSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+
+private:
+  void init();
+  std::string toText_impl(const std::string& html);
+  void toTextSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridHtmlToXml.cpp

@@ -0,0 +1,218 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridHtmlToXml.hpp"
+#include "HybridBinData.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridHtmlToXml::HybridHtmlToXml()
+    : HybridObject(HybridHtmlToXmlSpec::TAG), ChilkatObject<CkHtmlToXml>("HtmlToXml", CkHtmlToXml::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridHtmlToXml::HybridHtmlToXml(CkHtmlToXml* owned)
+    : HybridObject(HybridHtmlToXmlSpec::TAG), ChilkatObject<CkHtmlToXml>("HtmlToXml", owned) {
+  init();
+}
+
+void HybridHtmlToXml::init() {
+}
+
+void HybridHtmlToXml::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridHtmlToXml::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHtmlToXml::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHtmlToXml::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHtmlToXml::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHtmlToXml::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridHtmlToXml::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridHtmlToXml::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridHtmlToXml::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridHtmlToXml::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridHtmlToXml::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridHtmlToXml::getDropCustomTags() {
+  this->beginCall();
+  return this->ck().get_DropCustomTags();
+}
+void HybridHtmlToXml::setDropCustomTags(bool value) {
+  this->beginCall();
+  this->ck().put_DropCustomTags(value);
+}
+std::string HybridHtmlToXml::getHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Html(_s);
+  return rt::stdString(_s);
+}
+void HybridHtmlToXml::setHtml(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "html");
+  this->ck().put_Html(value.c_str());
+}
+double HybridHtmlToXml::getNbsp() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Nbsp());
+}
+void HybridHtmlToXml::setNbsp(double value) {
+  this->beginCall();
+  this->ck().put_Nbsp(rt::toInt(value, "nbsp"));
+}
+std::string HybridHtmlToXml::getXmlCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_XmlCharset(_s);
+  return rt::stdString(_s);
+}
+void HybridHtmlToXml::setXmlCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "xmlCharset");
+  this->ck().put_XmlCharset(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridHtmlToXml::convertFile(const std::string& inHtmlPath, const std::string& destXmlPath) {
+  this->beginCall();
+  convertFile_impl(inHtmlPath, destXmlPath);
+}
+void HybridHtmlToXml::convertFile_impl(const std::string& inHtmlPath, const std::string& destXmlPath) {
+  rt::checkNoNul(inHtmlPath, "inHtmlPath");
+  rt::checkNoNul(destXmlPath, "destXmlPath");
+  if (!this->ck().ConvertFile(inHtmlPath.c_str(), destXmlPath.c_str())) throw this->fail("convertFile");
+}
+
+void HybridHtmlToXml::dropTagType(const std::string& tagName) {
+  this->beginCall();
+  dropTagType_impl(tagName);
+}
+void HybridHtmlToXml::dropTagType_impl(const std::string& tagName) {
+  rt::checkNoNul(tagName, "tagName");
+  this->ck().DropTagType(tagName.c_str());
+}
+
+void HybridHtmlToXml::dropTextFormattingTags() {
+  this->beginCall();
+  dropTextFormattingTags_impl();
+}
+void HybridHtmlToXml::dropTextFormattingTags_impl() {
+  this->ck().DropTextFormattingTags();
+}
+
+void HybridHtmlToXml::setHtmlFromFile(const std::string& filename) {
+  this->beginCall();
+  setHtmlFromFile_impl(filename);
+}
+void HybridHtmlToXml::setHtmlFromFile_impl(const std::string& filename) {
+  rt::checkNoNul(filename, "filename");
+  if (!this->ck().SetHtmlFromFile(filename.c_str())) throw this->fail("setHtmlFromFile");
+}
+
+std::string HybridHtmlToXml::toXml() {
+  this->beginCall();
+  return toXml_impl();
+}
+std::string HybridHtmlToXml::toXml_impl() {
+  CkString _out;
+  if (!this->ck().ToXml(_out)) throw this->fail("toXml");
+  return rt::stdString(_out);
+}
+
+void HybridHtmlToXml::undropTagType(const std::string& tagName) {
+  this->beginCall();
+  undropTagType_impl(tagName);
+}
+void HybridHtmlToXml::undropTagType_impl(const std::string& tagName) {
+  rt::checkNoNul(tagName, "tagName");
+  this->ck().UndropTagType(tagName.c_str());
+}
+
+void HybridHtmlToXml::undropTextFormattingTags() {
+  this->beginCall();
+  undropTextFormattingTags_impl();
+}
+void HybridHtmlToXml::undropTextFormattingTags_impl() {
+  this->ck().UndropTextFormattingTags();
+}
+
+std::string HybridHtmlToXml::xml() {
+  this->beginCall();
+  return xml_impl();
+}
+std::string HybridHtmlToXml::xml_impl() {
+  CkString _out;
+  if (!this->ck().Xml(_out)) throw this->fail("xml");
+  return rt::stdString(_out);
+}
+
+void HybridHtmlToXml::setHtmlBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  setHtmlBd_impl(bd);
+}
+void HybridHtmlToXml::setHtmlBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().SetHtmlBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("setHtmlBd");
+}
+
+void HybridHtmlToXml::toXmlSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  toXmlSb_impl(sb);
+}
+void HybridHtmlToXml::toXmlSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().ToXmlSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("toXmlSb");
+}
+
+void HybridHtmlToXml::setHtmlSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  setHtmlSb_impl(sb);
+}
+void HybridHtmlToXml::setHtmlSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().SetHtmlSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("setHtmlSb");
+}
+
+} // namespace margelo::nitro::chilkat