@chilkat/react-native 11.6.1

package/cpp/HybridCsr.hpp

@@ -0,0 +1,77 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Csr: the Nitro HybridObject over Chilkat's CkCsr (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridCsrSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkCsr.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridCsr final : public HybridCsrSpec, public ChilkatObject<CkCsr> {
+public:
+  HybridCsr();                                  // `new Csr()` from JS
+  explicit HybridCsr(CkCsr* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  std::string getCommonName() override;
+  void setCommonName(const std::string& value) override;
+  std::string getCountry() override;
+  void setCountry(const std::string& value) override;
+  std::string getState() override;
+  void setState(const std::string& value) override;
+  std::string getLocality() override;
+  void setLocality(const std::string& value) override;
+  std::string getCompany() override;
+  void setCompany(const std::string& value) override;
+  std::string getCompanyDivision() override;
+  void setCompanyDivision(const std::string& value) override;
+  std::string getEmailAddress() override;
+  void setEmailAddress(const std::string& value) override;
+  std::string getHashAlgorithm() override;
+  void setHashAlgorithm(const std::string& value) override;
+  bool getPssPadding() override;
+  void setPssPadding(bool value) override;
+  std::string getMgfHashAlg() override;
+  void setMgfHashAlg(const std::string& value) override;
+
+  // ---- Methods ----
+  std::string genCsrPem(const std::shared_ptr<HybridPrivateKeySpec>& privKey) override;
+  void genCsrBd(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridBinDataSpec>& csrData) override;
+  void setSubjectField(const std::string& oid, const std::string& value, const std::string& asnType) override;
+  void loadCsrPem(const std::string& csrPemStr) override;
+  std::string getSubjectField(const std::string& oid) override;
+  void getPublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubkey) override;
+  void verifyCsr() override;
+  void addSan(const std::string& sanType, const std::string& sanValue) override;
+  void getSans(const std::shared_ptr<HybridStringTableSpec>& sans) override;
+  void setExtensionRequest(const std::shared_ptr<HybridXmlSpec>& extensionReqXml) override;
+  void getExtensionRequest(const std::shared_ptr<HybridXmlSpec>& extensionReqXml) override;
+
+private:
+  void init();
+  std::string genCsrPem_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey);
+  void genCsrBd_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridBinDataSpec>& csrData);
+  void setSubjectField_impl(const std::string& oid, const std::string& value, const std::string& asnType);
+  void loadCsrPem_impl(const std::string& csrPemStr);
+  std::string getSubjectField_impl(const std::string& oid);
+  void getPublicKey_impl(const std::shared_ptr<HybridPublicKeySpec>& pubkey);
+  void verifyCsr_impl();
+  void addSan_impl(const std::string& sanType, const std::string& sanValue);
+  void getSans_impl(const std::shared_ptr<HybridStringTableSpec>& sans);
+  void setExtensionRequest_impl(const std::shared_ptr<HybridXmlSpec>& extensionReqXml);
+  void getExtensionRequest_impl(const std::shared_ptr<HybridXmlSpec>& extensionReqXml);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridCsv.cpp

@@ -0,0 +1,382 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridCsv.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridStringTable.hpp"
+#include "HybridZip.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridCsv::HybridCsv()
+    : HybridObject(HybridCsvSpec::TAG), ChilkatObject<CkCsv>("Csv", CkCsv::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridCsv::HybridCsv(CkCsv* owned)
+    : HybridObject(HybridCsvSpec::TAG), ChilkatObject<CkCsv>("Csv", owned) {
+  init();
+}
+
+void HybridCsv::init() {
+}
+
+void HybridCsv::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridCsv::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCsv::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCsv::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCsv::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridCsv::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridCsv::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridCsv::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridCsv::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridCsv::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridCsv::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridCsv::getAutoTrim() {
+  this->beginCall();
+  return this->ck().get_AutoTrim();
+}
+void HybridCsv::setAutoTrim(bool value) {
+  this->beginCall();
+  this->ck().put_AutoTrim(value);
+}
+bool HybridCsv::getCrlf() {
+  this->beginCall();
+  return this->ck().get_Crlf();
+}
+void HybridCsv::setCrlf(bool value) {
+  this->beginCall();
+  this->ck().put_Crlf(value);
+}
+std::string HybridCsv::getDelimiter() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Delimiter(_s);
+  return rt::stdString(_s);
+}
+void HybridCsv::setDelimiter(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "delimiter");
+  this->ck().put_Delimiter(value.c_str());
+}
+bool HybridCsv::getEscapeBackslash() {
+  this->beginCall();
+  return this->ck().get_EscapeBackslash();
+}
+void HybridCsv::setEscapeBackslash(bool value) {
+  this->beginCall();
+  this->ck().put_EscapeBackslash(value);
+}
+bool HybridCsv::getHasColumnNames() {
+  this->beginCall();
+  return this->ck().get_HasColumnNames();
+}
+void HybridCsv::setHasColumnNames(bool value) {
+  this->beginCall();
+  this->ck().put_HasColumnNames(value);
+}
+double HybridCsv::getNumColumns() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumColumns());
+}
+double HybridCsv::getNumRows() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumRows());
+}
+bool HybridCsv::getEnableQuotes() {
+  this->beginCall();
+  return this->ck().get_EnableQuotes();
+}
+void HybridCsv::setEnableQuotes(bool value) {
+  this->beginCall();
+  this->ck().put_EnableQuotes(value);
+}
+std::string HybridCsv::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridCsv::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+std::string HybridCsv::getXlsxDateFormat() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_XlsxDateFormat(_s);
+  return rt::stdString(_s);
+}
+void HybridCsv::setXlsxDateFormat(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "xlsxDateFormat");
+  this->ck().put_XlsxDateFormat(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridCsv::deleteColumn(double index) {
+  this->beginCall();
+  deleteColumn_impl(index);
+}
+void HybridCsv::deleteColumn_impl(double index) {
+  if (!this->ck().DeleteColumn(rt::toInt(index, "index"))) throw this->fail("deleteColumn");
+}
+
+void HybridCsv::deleteColumnByName(const std::string& columnName) {
+  this->beginCall();
+  deleteColumnByName_impl(columnName);
+}
+void HybridCsv::deleteColumnByName_impl(const std::string& columnName) {
+  rt::checkNoNul(columnName, "columnName");
+  if (!this->ck().DeleteColumnByName(columnName.c_str())) throw this->fail("deleteColumnByName");
+}
+
+void HybridCsv::deleteRow(double index) {
+  this->beginCall();
+  deleteRow_impl(index);
+}
+void HybridCsv::deleteRow_impl(double index) {
+  if (!this->ck().DeleteRow(rt::toInt(index, "index"))) throw this->fail("deleteRow");
+}
+
+std::string HybridCsv::getCell(double row, double col) {
+  this->beginCall();
+  return getCell_impl(row, col);
+}
+std::string HybridCsv::getCell_impl(double row, double col) {
+  CkString _out;
+  if (!this->ck().GetCell(rt::toInt(row, "row"), rt::toInt(col, "col"), _out)) throw this->fail("getCell");
+  return rt::stdString(_out);
+}
+
+std::string HybridCsv::getCellByName(double rowIndex, const std::string& columnName) {
+  this->beginCall();
+  return getCellByName_impl(rowIndex, columnName);
+}
+std::string HybridCsv::getCellByName_impl(double rowIndex, const std::string& columnName) {
+  rt::checkNoNul(columnName, "columnName");
+  CkString _out;
+  if (!this->ck().GetCellByName(rt::toInt(rowIndex, "rowIndex"), columnName.c_str(), _out)) throw this->fail("getCellByName");
+  return rt::stdString(_out);
+}
+
+std::string HybridCsv::getColumnName(double index) {
+  this->beginCall();
+  return getColumnName_impl(index);
+}
+std::string HybridCsv::getColumnName_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetColumnName(rt::toInt(index, "index"), _out)) throw this->fail("getColumnName");
+  return rt::stdString(_out);
+}
+
+double HybridCsv::getIndex(const std::string& columnName) {
+  this->beginCall();
+  return getIndex_impl(columnName);
+}
+double HybridCsv::getIndex_impl(const std::string& columnName) {
+  rt::checkNoNul(columnName, "columnName");
+  return static_cast<double>(this->ck().GetIndex(columnName.c_str()));
+}
+
+double HybridCsv::getNumCols(double row) {
+  this->beginCall();
+  return getNumCols_impl(row);
+}
+double HybridCsv::getNumCols_impl(double row) {
+  return static_cast<double>(this->ck().GetNumCols(rt::toInt(row, "row")));
+}
+
+void HybridCsv::loadFile(const std::string& path) {
+  this->beginCall();
+  loadFile_impl(path);
+}
+void HybridCsv::loadFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().LoadFile(path.c_str())) throw this->fail("loadFile");
+}
+
+void HybridCsv::loadFile2(const std::string& filename, const std::string& charset) {
+  this->beginCall();
+  loadFile2_impl(filename, charset);
+}
+void HybridCsv::loadFile2_impl(const std::string& filename, const std::string& charset) {
+  rt::checkNoNul(filename, "filename");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().LoadFile2(filename.c_str(), charset.c_str())) throw this->fail("loadFile2");
+}
+
+void HybridCsv::loadFromString(const std::string& csvData) {
+  this->beginCall();
+  loadFromString_impl(csvData);
+}
+void HybridCsv::loadFromString_impl(const std::string& csvData) {
+  rt::checkNoNul(csvData, "csvData");
+  if (!this->ck().LoadFromString(csvData.c_str())) throw this->fail("loadFromString");
+}
+
+bool HybridCsv::rowMatches(double rowIndex, const std::string& matchPattern, bool caseSensitive) {
+  this->beginCall();
+  return rowMatches_impl(rowIndex, matchPattern, caseSensitive);
+}
+bool HybridCsv::rowMatches_impl(double rowIndex, const std::string& matchPattern, bool caseSensitive) {
+  rt::checkNoNul(matchPattern, "matchPattern");
+  return this->ck().RowMatches(rt::toInt(rowIndex, "rowIndex"), matchPattern.c_str(), caseSensitive);
+}
+
+void HybridCsv::saveFile(const std::string& path) {
+  this->beginCall();
+  saveFile_impl(path);
+}
+void HybridCsv::saveFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SaveFile(path.c_str())) throw this->fail("saveFile");
+}
+
+void HybridCsv::saveFile2(const std::string& filename, const std::string& charset) {
+  this->beginCall();
+  saveFile2_impl(filename, charset);
+}
+void HybridCsv::saveFile2_impl(const std::string& filename, const std::string& charset) {
+  rt::checkNoNul(filename, "filename");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().SaveFile2(filename.c_str(), charset.c_str())) throw this->fail("saveFile2");
+}
+
+std::string HybridCsv::saveToString() {
+  this->beginCall();
+  return saveToString_impl();
+}
+std::string HybridCsv::saveToString_impl() {
+  CkString _out;
+  if (!this->ck().SaveToString(_out)) throw this->fail("saveToString");
+  return rt::stdString(_out);
+}
+
+void HybridCsv::setCell(double row, double col, const std::string& content) {
+  this->beginCall();
+  setCell_impl(row, col, content);
+}
+void HybridCsv::setCell_impl(double row, double col, const std::string& content) {
+  rt::checkNoNul(content, "content");
+  if (!this->ck().SetCell(rt::toInt(row, "row"), rt::toInt(col, "col"), content.c_str())) throw this->fail("setCell");
+}
+
+void HybridCsv::setCellByName(double rowIndex, const std::string& columnName, const std::string& contentStr) {
+  this->beginCall();
+  setCellByName_impl(rowIndex, columnName, contentStr);
+}
+void HybridCsv::setCellByName_impl(double rowIndex, const std::string& columnName, const std::string& contentStr) {
+  rt::checkNoNul(columnName, "columnName");
+  rt::checkNoNul(contentStr, "contentStr");
+  if (!this->ck().SetCellByName(rt::toInt(rowIndex, "rowIndex"), columnName.c_str(), contentStr.c_str())) throw this->fail("setCellByName");
+}
+
+void HybridCsv::setColumnName(double index, const std::string& columnName) {
+  this->beginCall();
+  setColumnName_impl(index, columnName);
+}
+void HybridCsv::setColumnName_impl(double index, const std::string& columnName) {
+  rt::checkNoNul(columnName, "columnName");
+  if (!this->ck().SetColumnName(rt::toInt(index, "index"), columnName.c_str())) throw this->fail("setColumnName");
+}
+
+void HybridCsv::sortByColumn(const std::string& columnName, bool ascending, bool caseSensitive) {
+  this->beginCall();
+  sortByColumn_impl(columnName, ascending, caseSensitive);
+}
+void HybridCsv::sortByColumn_impl(const std::string& columnName, bool ascending, bool caseSensitive) {
+  rt::checkNoNul(columnName, "columnName");
+  if (!this->ck().SortByColumn(columnName.c_str(), ascending, caseSensitive)) throw this->fail("sortByColumn");
+}
+
+void HybridCsv::sortByColumnIndex(double index, bool ascending, bool caseSensitive) {
+  this->beginCall();
+  sortByColumnIndex_impl(index, ascending, caseSensitive);
+}
+void HybridCsv::sortByColumnIndex_impl(double index, bool ascending, bool caseSensitive) {
+  if (!this->ck().SortByColumnIndex(rt::toInt(index, "index"), ascending, caseSensitive)) throw this->fail("sortByColumnIndex");
+}
+
+void HybridCsv::insertColumn(double index) {
+  this->beginCall();
+  insertColumn_impl(index);
+}
+void HybridCsv::insertColumn_impl(double index) {
+  if (!this->ck().InsertColumn(rt::toInt(index, "index"))) throw this->fail("insertColumn");
+}
+
+void HybridCsv::saveToSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  saveToSb_impl(sb);
+}
+void HybridCsv::saveToSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().SaveToSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("saveToSb");
+}
+
+void HybridCsv::xlsxGetSheets(const std::shared_ptr<HybridZipSpec>& xlsx, const std::shared_ptr<HybridStringTableSpec>& sheetNames) {
+  this->beginCall();
+  xlsxGetSheets_impl(xlsx, sheetNames);
+}
+void HybridCsv::xlsxGetSheets_impl(const std::shared_ptr<HybridZipSpec>& xlsx, const std::shared_ptr<HybridStringTableSpec>& sheetNames) {
+  if (!this->ck().XlsxGetSheets(rt::implOf<HybridZip>(xlsx, "xlsx").ck(), rt::implOf<HybridStringTable>(sheetNames, "sheetNames").ck())) throw this->fail("xlsxGetSheets");
+}
+
+void HybridCsv::xlsxLoadSheet(const std::shared_ptr<HybridZipSpec>& zip, const std::string& sheetName) {
+  this->beginCall();
+  xlsxLoadSheet_impl(zip, sheetName);
+}
+void HybridCsv::xlsxLoadSheet_impl(const std::shared_ptr<HybridZipSpec>& zip, const std::string& sheetName) {
+  rt::checkNoNul(sheetName, "sheetName");
+  if (!this->ck().XlsxLoadSheet(rt::implOf<HybridZip>(zip, "zip").ck(), sheetName.c_str())) throw this->fail("xlsxLoadSheet");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridCsv.hpp

@@ -0,0 +1,101 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Csv: the Nitro HybridObject over Chilkat's CkCsv (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridCsvSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkCsv.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridCsv final : public HybridCsvSpec, public ChilkatObject<CkCsv> {
+public:
+  HybridCsv();                                  // `new Csv()` from JS
+  explicit HybridCsv(CkCsv* 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 getAutoTrim() override;
+  void setAutoTrim(bool value) override;
+  bool getCrlf() override;
+  void setCrlf(bool value) override;
+  std::string getDelimiter() override;
+  void setDelimiter(const std::string& value) override;
+  bool getEscapeBackslash() override;
+  void setEscapeBackslash(bool value) override;
+  bool getHasColumnNames() override;
+  void setHasColumnNames(bool value) override;
+  double getNumColumns() override;
+  double getNumRows() override;
+  bool getEnableQuotes() override;
+  void setEnableQuotes(bool value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+  std::string getXlsxDateFormat() override;
+  void setXlsxDateFormat(const std::string& value) override;
+
+  // ---- Methods ----
+  void deleteColumn(double index) override;
+  void deleteColumnByName(const std::string& columnName) override;
+  void deleteRow(double index) override;
+  std::string getCell(double row, double col) override;
+  std::string getCellByName(double rowIndex, const std::string& columnName) override;
+  std::string getColumnName(double index) override;
+  double getIndex(const std::string& columnName) override;
+  double getNumCols(double row) override;
+  void loadFile(const std::string& path) override;
+  void loadFile2(const std::string& filename, const std::string& charset) override;
+  void loadFromString(const std::string& csvData) override;
+  bool rowMatches(double rowIndex, const std::string& matchPattern, bool caseSensitive) override;
+  void saveFile(const std::string& path) override;
+  void saveFile2(const std::string& filename, const std::string& charset) override;
+  std::string saveToString() override;
+  void setCell(double row, double col, const std::string& content) override;
+  void setCellByName(double rowIndex, const std::string& columnName, const std::string& contentStr) override;
+  void setColumnName(double index, const std::string& columnName) override;
+  void sortByColumn(const std::string& columnName, bool ascending, bool caseSensitive) override;
+  void sortByColumnIndex(double index, bool ascending, bool caseSensitive) override;
+  void insertColumn(double index) override;
+  void saveToSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void xlsxGetSheets(const std::shared_ptr<HybridZipSpec>& xlsx, const std::shared_ptr<HybridStringTableSpec>& sheetNames) override;
+  void xlsxLoadSheet(const std::shared_ptr<HybridZipSpec>& zip, const std::string& sheetName) override;
+
+private:
+  void init();
+  void deleteColumn_impl(double index);
+  void deleteColumnByName_impl(const std::string& columnName);
+  void deleteRow_impl(double index);
+  std::string getCell_impl(double row, double col);
+  std::string getCellByName_impl(double rowIndex, const std::string& columnName);
+  std::string getColumnName_impl(double index);
+  double getIndex_impl(const std::string& columnName);
+  double getNumCols_impl(double row);
+  void loadFile_impl(const std::string& path);
+  void loadFile2_impl(const std::string& filename, const std::string& charset);
+  void loadFromString_impl(const std::string& csvData);
+  bool rowMatches_impl(double rowIndex, const std::string& matchPattern, bool caseSensitive);
+  void saveFile_impl(const std::string& path);
+  void saveFile2_impl(const std::string& filename, const std::string& charset);
+  std::string saveToString_impl();
+  void setCell_impl(double row, double col, const std::string& content);
+  void setCellByName_impl(double rowIndex, const std::string& columnName, const std::string& contentStr);
+  void setColumnName_impl(double index, const std::string& columnName);
+  void sortByColumn_impl(const std::string& columnName, bool ascending, bool caseSensitive);
+  void sortByColumnIndex_impl(double index, bool ascending, bool caseSensitive);
+  void insertColumn_impl(double index);
+  void saveToSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void xlsxGetSheets_impl(const std::shared_ptr<HybridZipSpec>& xlsx, const std::shared_ptr<HybridStringTableSpec>& sheetNames);
+  void xlsxLoadSheet_impl(const std::shared_ptr<HybridZipSpec>& zip, const std::string& sheetName);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridDh.cpp

@@ -0,0 +1,137 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridDh.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridDh::HybridDh()
+    : HybridObject(HybridDhSpec::TAG), ChilkatObject<CkDh>("Dh", CkDh::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridDh::HybridDh(CkDh* owned)
+    : HybridObject(HybridDhSpec::TAG), ChilkatObject<CkDh>("Dh", owned) {
+  init();
+}
+
+void HybridDh::init() {
+}
+
+void HybridDh::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridDh::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDh::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDh::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDh::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDh::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridDh::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridDh::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridDh::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridDh::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridDh::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridDh::getG() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_G());
+}
+std::string HybridDh::getP() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_P(_s);
+  return rt::stdString(_s);
+}
+
+// ---- Methods ----
+
+std::string HybridDh::createE(double numBits) {
+  this->beginCall();
+  return createE_impl(numBits);
+}
+std::string HybridDh::createE_impl(double numBits) {
+  CkString _out;
+  if (!this->ck().CreateE(rt::toInt(numBits, "numBits"), _out)) throw this->fail("createE");
+  return rt::stdString(_out);
+}
+
+std::string HybridDh::findK(const std::string& e) {
+  this->beginCall();
+  return findK_impl(e);
+}
+std::string HybridDh::findK_impl(const std::string& e) {
+  rt::checkNoNul(e, "e");
+  CkString _out;
+  if (!this->ck().FindK(e.c_str(), _out)) throw this->fail("findK");
+  return rt::stdString(_out);
+}
+
+void HybridDh::genPG(double numBits, double g) {
+  this->beginCall();
+  genPG_impl(numBits, g);
+}
+void HybridDh::genPG_impl(double numBits, double g) {
+  if (!this->ck().GenPG(rt::toInt(numBits, "numBits"), rt::toInt(g, "g"))) throw this->fail("genPG");
+}
+
+void HybridDh::setPG(const std::string& p, double g) {
+  this->beginCall();
+  setPG_impl(p, g);
+}
+void HybridDh::setPG_impl(const std::string& p, double g) {
+  rt::checkNoNul(p, "p");
+  if (!this->ck().SetPG(p.c_str(), rt::toInt(g, "g"))) throw this->fail("setPG");
+}
+
+void HybridDh::useKnownPrime(double index) {
+  this->beginCall();
+  useKnownPrime_impl(index);
+}
+void HybridDh::useKnownPrime_impl(double index) {
+  this->ck().UseKnownPrime(rt::toInt(index, "index"));
+}
+
+} // namespace margelo::nitro::chilkat