@chilkat/react-native 11.6.1

package/cpp/HybridStringBuilder.hpp

@@ -0,0 +1,178 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// StringBuilder: the Nitro HybridObject over Chilkat's CkStringBuilder (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridStringBuilderSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkStringBuilder.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridStringBuilder final : public HybridStringBuilderSpec, public ChilkatObject<CkStringBuilder> {
+public:
+  HybridStringBuilder();                                  // `new StringBuilder()` from JS
+  explicit HybridStringBuilder(CkStringBuilder* 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 getLength() override;
+  double getIntValue() override;
+  void setIntValue(double value) override;
+  bool getIsBase64() override;
+  bool getHasEmojis() override;
+
+  // ---- Methods ----
+  void append(const std::string& value) override;
+  void appendInt(double value) override;
+  void appendInt64(double value) override;
+  void clear() override;
+  double replace(const std::string& value, const std::string& replacement) override;
+  std::string getAsString() override;
+  bool contentsEqual(const std::string& str, bool caseSensitive) override;
+  bool contains(const std::string& str, bool caseSensitive) override;
+  bool isWellFormed(const std::string& format) override;
+  void prepend(const std::string& value) override;
+  void setString(const std::string& value) override;
+  void encode(const std::string& encoding, const std::string& charset) override;
+  std::string getEncoded(const std::string& encoding, const std::string& charset) override;
+  void decode(const std::string& encoding, const std::string& charset) override;
+  void trim() override;
+  void trimInsideSpaces() override;
+  bool startsWith(const std::string& substr, bool caseSensitive) override;
+  bool endsWith(const std::string& substr, bool caseSensitive) override;
+  void toLowercase() override;
+  void toUppercase() override;
+  void toCRLF() override;
+  void toLF() override;
+  void entityDecode() override;
+  double replaceWord(const std::string& value, const std::string& replacement) override;
+  double replaceBetween(const std::string& beginMark, const std::string& endMark, const std::string& value, const std::string& replacement) override;
+  std::string getBetween(const std::string& beginMark, const std::string& endMark) override;
+  std::string getAfterBetween(const std::string& searchAfter, const std::string& beginMark, const std::string& endMark) override;
+  std::string getNth(double index, const std::string& delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped) override;
+  void setNth(double index, const std::string& value, const std::string& delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped) override;
+  void loadFile(const std::string& path, const std::string& charset) override;
+  void writeFile(const std::string& path, const std::string& charset, bool emitBom) override;
+  void appendSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  bool contentsEqualSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool caseSensitive) override;
+  std::string lastNLines(double numLines, bool bCrlf) override;
+  void appendBd(const std::shared_ptr<HybridBinDataSpec>& binData, const std::string& charset, double offset, double numBytes) override;
+  void replaceAllBetween(const std::string& beginMark, const std::string& endMark, const std::string& replacement, bool replaceMarks) override;
+  void appendLine(const std::string& str, bool crlf) override;
+  void secureClear() override;
+  double replaceI(const std::string& value, double replacement) override;
+  bool containsWord(const std::string& word, bool caseSensitive) override;
+  void punyEncode() override;
+  void punyDecode() override;
+  void replaceAfterFinal(const std::string& marker, const std::string& replacement) override;
+  void writeFileIfModified(const std::string& path, const std::string& charset, bool emitBom) override;
+  std::string getBefore(const std::string& marker, bool removeFlag) override;
+  void removeBefore(const std::string& marker) override;
+  void replaceFirst(const std::string& value, const std::string& replacement) override;
+  std::string getAfterFinal(const std::string& marker, bool removeFlag) override;
+  void removeAfterFinal(const std::string& marker) override;
+  void obfuscate() override;
+  void unobfuscate() override;
+  double replaceNoCase(const std::string& value, const std::string& replacement) override;
+  void decodeAndAppend(const std::string& value, const std::string& encoding, const std::string& charset) override;
+  void shorten(double numChars) override;
+  void removeCharsAt(double startIndex, double numChars) override;
+  std::string getRange(double startIndex, double numChars, bool removeFlag) override;
+  std::string getHash(const std::string& algorithm, const std::string& encoding, const std::string& charset) override;
+  void removeAccents() override;
+  void appendUuid(bool lowerCase) override;
+  void appendRandom(double numBytes, const std::string& encoding) override;
+  void appendUuid7(bool lowerCase) override;
+  void removeEmojis() override;
+  double regexMatch(const std::string& pattern, const std::shared_ptr<HybridJsonObjectSpec>& json, double timeoutMs) override;
+  void regexReplace(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void maskQuotedStrings(const std::string& maskChar, double quoteType, const std::shared_ptr<HybridStringTableSpec>& maskedStrings) override;
+  void restoreMaskedStrings(double quoteType, const std::shared_ptr<HybridStringTableSpec>& maskedStrings) override;
+  void markdownToHtml(const std::shared_ptr<HybridJsonObjectSpec>& options, const std::shared_ptr<HybridStringBuilderSpec>& sbHtml) override;
+  void getRangeSb(double startIndex, double numChars, bool removeFlag, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void appendLn(const std::string& str) override;
+
+private:
+  void init();
+  void append_impl(const std::string& value);
+  void appendInt_impl(double value);
+  void appendInt64_impl(double value);
+  void clear_impl();
+  double replace_impl(const std::string& value, const std::string& replacement);
+  std::string getAsString_impl();
+  bool contentsEqual_impl(const std::string& str, bool caseSensitive);
+  bool contains_impl(const std::string& str, bool caseSensitive);
+  bool isWellFormed_impl(const std::string& format);
+  void prepend_impl(const std::string& value);
+  void setString_impl(const std::string& value);
+  void encode_impl(const std::string& encoding, const std::string& charset);
+  std::string getEncoded_impl(const std::string& encoding, const std::string& charset);
+  void decode_impl(const std::string& encoding, const std::string& charset);
+  void trim_impl();
+  void trimInsideSpaces_impl();
+  bool startsWith_impl(const std::string& substr, bool caseSensitive);
+  bool endsWith_impl(const std::string& substr, bool caseSensitive);
+  void toLowercase_impl();
+  void toUppercase_impl();
+  void toCRLF_impl();
+  void toLF_impl();
+  void entityDecode_impl();
+  double replaceWord_impl(const std::string& value, const std::string& replacement);
+  double replaceBetween_impl(const std::string& beginMark, const std::string& endMark, const std::string& value, const std::string& replacement);
+  std::string getBetween_impl(const std::string& beginMark, const std::string& endMark);
+  std::string getAfterBetween_impl(const std::string& searchAfter, const std::string& beginMark, const std::string& endMark);
+  std::string getNth_impl(double index, const std::string& delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped);
+  void setNth_impl(double index, const std::string& value, const std::string& delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped);
+  void loadFile_impl(const std::string& path, const std::string& charset);
+  void writeFile_impl(const std::string& path, const std::string& charset, bool emitBom);
+  void appendSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  bool contentsEqualSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool caseSensitive);
+  std::string lastNLines_impl(double numLines, bool bCrlf);
+  void appendBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData, const std::string& charset, double offset, double numBytes);
+  void replaceAllBetween_impl(const std::string& beginMark, const std::string& endMark, const std::string& replacement, bool replaceMarks);
+  void appendLine_impl(const std::string& str, bool crlf);
+  void secureClear_impl();
+  double replaceI_impl(const std::string& value, double replacement);
+  bool containsWord_impl(const std::string& word, bool caseSensitive);
+  void punyEncode_impl();
+  void punyDecode_impl();
+  void replaceAfterFinal_impl(const std::string& marker, const std::string& replacement);
+  void writeFileIfModified_impl(const std::string& path, const std::string& charset, bool emitBom);
+  std::string getBefore_impl(const std::string& marker, bool removeFlag);
+  void removeBefore_impl(const std::string& marker);
+  void replaceFirst_impl(const std::string& value, const std::string& replacement);
+  std::string getAfterFinal_impl(const std::string& marker, bool removeFlag);
+  void removeAfterFinal_impl(const std::string& marker);
+  void obfuscate_impl();
+  void unobfuscate_impl();
+  double replaceNoCase_impl(const std::string& value, const std::string& replacement);
+  void decodeAndAppend_impl(const std::string& value, const std::string& encoding, const std::string& charset);
+  void shorten_impl(double numChars);
+  void removeCharsAt_impl(double startIndex, double numChars);
+  std::string getRange_impl(double startIndex, double numChars, bool removeFlag);
+  std::string getHash_impl(const std::string& algorithm, const std::string& encoding, const std::string& charset);
+  void removeAccents_impl();
+  void appendUuid_impl(bool lowerCase);
+  void appendRandom_impl(double numBytes, const std::string& encoding);
+  void appendUuid7_impl(bool lowerCase);
+  void removeEmojis_impl();
+  double regexMatch_impl(const std::string& pattern, const std::shared_ptr<HybridJsonObjectSpec>& json, double timeoutMs);
+  void regexReplace_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void maskQuotedStrings_impl(const std::string& maskChar, double quoteType, const std::shared_ptr<HybridStringTableSpec>& maskedStrings);
+  void restoreMaskedStrings_impl(double quoteType, const std::shared_ptr<HybridStringTableSpec>& maskedStrings);
+  void markdownToHtml_impl(const std::shared_ptr<HybridJsonObjectSpec>& options, const std::shared_ptr<HybridStringBuilderSpec>& sbHtml);
+  void getRangeSb_impl(double startIndex, double numChars, bool removeFlag, const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void appendLn_impl(const std::string& str);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridStringTable.cpp

@@ -0,0 +1,218 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridStringTable.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridStringTable::HybridStringTable()
+    : HybridObject(HybridStringTableSpec::TAG), ChilkatObject<CkStringTable>("StringTable", CkStringTable::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridStringTable::HybridStringTable(CkStringTable* owned)
+    : HybridObject(HybridStringTableSpec::TAG), ChilkatObject<CkStringTable>("StringTable", owned) {
+  init();
+}
+
+void HybridStringTable::init() {
+}
+
+void HybridStringTable::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridStringTable::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStringTable::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStringTable::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStringTable::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridStringTable::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridStringTable::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridStringTable::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridStringTable::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridStringTable::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridStringTable::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridStringTable::getCount() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Count());
+}
+
+// ---- Methods ----
+
+void HybridStringTable::appendFromFile(double maxLineLen, const std::string& charset, const std::string& path) {
+  this->beginCall();
+  appendFromFile_impl(maxLineLen, charset, path);
+}
+void HybridStringTable::appendFromFile_impl(double maxLineLen, const std::string& charset, const std::string& path) {
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(path, "path");
+  if (!this->ck().AppendFromFile(rt::toInt(maxLineLen, "maxLineLen"), charset.c_str(), path.c_str())) throw this->fail("appendFromFile");
+}
+
+void HybridStringTable::append(const std::string& value) {
+  this->beginCall();
+  append_impl(value);
+}
+void HybridStringTable::append_impl(const std::string& value) {
+  rt::checkNoNul(value, "value");
+  if (!this->ck().Append(value.c_str())) throw this->fail("append");
+}
+
+std::string HybridStringTable::stringAt(double index) {
+  this->beginCall();
+  return stringAt_impl(index);
+}
+std::string HybridStringTable::stringAt_impl(double index) {
+  CkString _out;
+  if (!this->ck().StringAt(rt::toInt(index, "index"), _out)) throw this->fail("stringAt");
+  return rt::stdString(_out);
+}
+
+void HybridStringTable::saveToFile(const std::string& charset, bool bCrlf, const std::string& path) {
+  this->beginCall();
+  saveToFile_impl(charset, bCrlf, path);
+}
+void HybridStringTable::saveToFile_impl(const std::string& charset, bool bCrlf, const std::string& path) {
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SaveToFile(charset.c_str(), bCrlf, path.c_str())) throw this->fail("saveToFile");
+}
+
+void HybridStringTable::splitAndAppend(const std::string& inStr, const std::string& delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped) {
+  this->beginCall();
+  splitAndAppend_impl(inStr, delimiterChar, exceptDoubleQuoted, exceptEscaped);
+}
+void HybridStringTable::splitAndAppend_impl(const std::string& inStr, const std::string& delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped) {
+  rt::checkNoNul(inStr, "inStr");
+  rt::checkNoNul(delimiterChar, "delimiterChar");
+  if (!this->ck().SplitAndAppend(inStr.c_str(), delimiterChar.c_str(), exceptDoubleQuoted, exceptEscaped)) throw this->fail("splitAndAppend");
+}
+
+void HybridStringTable::appendFromSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  appendFromSb_impl(sb);
+}
+void HybridStringTable::appendFromSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().AppendFromSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("appendFromSb");
+}
+
+void HybridStringTable::clear() {
+  this->beginCall();
+  clear_impl();
+}
+void HybridStringTable::clear_impl() {
+  this->ck().Clear();
+}
+
+double HybridStringTable::intAt(double index) {
+  this->beginCall();
+  return intAt_impl(index);
+}
+double HybridStringTable::intAt_impl(double index) {
+  return static_cast<double>(this->ck().IntAt(rt::toInt(index, "index")));
+}
+
+double HybridStringTable::findSubstring(double startIndex, const std::string& substr, bool caseSensitive) {
+  this->beginCall();
+  return findSubstring_impl(startIndex, substr, caseSensitive);
+}
+double HybridStringTable::findSubstring_impl(double startIndex, const std::string& substr, bool caseSensitive) {
+  rt::checkNoNul(substr, "substr");
+  return static_cast<double>(this->ck().FindSubstring(rt::toInt(startIndex, "startIndex"), substr.c_str(), caseSensitive));
+}
+
+void HybridStringTable::sort(bool ascending, bool caseSensitive) {
+  this->beginCall();
+  sort_impl(ascending, caseSensitive);
+}
+void HybridStringTable::sort_impl(bool ascending, bool caseSensitive) {
+  if (!this->ck().Sort(ascending, caseSensitive)) throw this->fail("sort");
+}
+
+std::string HybridStringTable::getStrings(double startIdx, double count, bool crlf) {
+  this->beginCall();
+  return getStrings_impl(startIdx, count, crlf);
+}
+std::string HybridStringTable::getStrings_impl(double startIdx, double count, bool crlf) {
+  CkString _out;
+  if (!this->ck().GetStrings(rt::toInt(startIdx, "startIdx"), rt::toInt(count, "count"), crlf, _out)) throw this->fail("getStrings");
+  return rt::stdString(_out);
+}
+
+double HybridStringTable::findMatch(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool caseSensitive) {
+  this->beginCall();
+  return findMatch_impl(sb, caseSensitive);
+}
+double HybridStringTable::findMatch_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool caseSensitive) {
+  return static_cast<double>(this->ck().FindMatch(rt::implOf<HybridStringBuilder>(sb, "sb").ck(), caseSensitive));
+}
+
+double HybridStringTable::wordFollowing(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool captureEmailAddr, const std::shared_ptr<HybridStringBuilderSpec>& sbWord) {
+  this->beginCall();
+  return wordFollowing_impl(sb, captureEmailAddr, sbWord);
+}
+double HybridStringTable::wordFollowing_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool captureEmailAddr, const std::shared_ptr<HybridStringBuilderSpec>& sbWord) {
+  return static_cast<double>(this->ck().WordFollowing(rt::implOf<HybridStringBuilder>(sb, "sb").ck(), captureEmailAddr, rt::implOf<HybridStringBuilder>(sbWord, "sbWord").ck()));
+}
+
+void HybridStringTable::stringAtSb(double index, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  stringAtSb_impl(index, sb);
+}
+void HybridStringTable::stringAtSb_impl(double index, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().StringAtSb(rt::toInt(index, "index"), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("stringAtSb");
+}
+
+void HybridStringTable::toSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  toSb_impl(sb);
+}
+void HybridStringTable::toSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().ToSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("toSb");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridStringTable.hpp

@@ -0,0 +1,66 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// StringTable: the Nitro HybridObject over Chilkat's CkStringTable (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridStringTableSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkStringTable.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridStringTable final : public HybridStringTableSpec, public ChilkatObject<CkStringTable> {
+public:
+  HybridStringTable();                                  // `new StringTable()` from JS
+  explicit HybridStringTable(CkStringTable* 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 appendFromFile(double maxLineLen, const std::string& charset, const std::string& path) override;
+  void append(const std::string& value) override;
+  std::string stringAt(double index) override;
+  void saveToFile(const std::string& charset, bool bCrlf, const std::string& path) override;
+  void splitAndAppend(const std::string& inStr, const std::string& delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped) override;
+  void appendFromSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void clear() override;
+  double intAt(double index) override;
+  double findSubstring(double startIndex, const std::string& substr, bool caseSensitive) override;
+  void sort(bool ascending, bool caseSensitive) override;
+  std::string getStrings(double startIdx, double count, bool crlf) override;
+  double findMatch(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool caseSensitive) override;
+  double wordFollowing(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool captureEmailAddr, const std::shared_ptr<HybridStringBuilderSpec>& sbWord) override;
+  void stringAtSb(double index, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void toSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+
+private:
+  void init();
+  void appendFromFile_impl(double maxLineLen, const std::string& charset, const std::string& path);
+  void append_impl(const std::string& value);
+  std::string stringAt_impl(double index);
+  void saveToFile_impl(const std::string& charset, bool bCrlf, const std::string& path);
+  void splitAndAppend_impl(const std::string& inStr, const std::string& delimiterChar, bool exceptDoubleQuoted, bool exceptEscaped);
+  void appendFromSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void clear_impl();
+  double intAt_impl(double index);
+  double findSubstring_impl(double startIndex, const std::string& substr, bool caseSensitive);
+  void sort_impl(bool ascending, bool caseSensitive);
+  std::string getStrings_impl(double startIdx, double count, bool crlf);
+  double findMatch_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool caseSensitive);
+  double wordFollowing_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool captureEmailAddr, const std::shared_ptr<HybridStringBuilderSpec>& sbWord);
+  void stringAtSb_impl(double index, const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void toSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+};
+
+} // namespace margelo::nitro::chilkat