@chilkat/react-native 11.6.1

package/cpp/HybridJs.hpp

@@ -0,0 +1,54 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Js: the Nitro HybridObject over Chilkat's CkJs (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridJsSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkJs.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridJs final : public HybridJsSpec, public ChilkatObject<CkJs> {
+public:
+  HybridJs();                                  // `new Js()` from JS
+  explicit HybridJs(CkJs* 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 getTimeoutSeconds() override;
+  void setTimeoutSeconds(double value) override;
+
+  // ---- Methods ----
+  void eval(const std::shared_ptr<HybridStringBuilderSpec>& jscript, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) override;
+  std::shared_ptr<Promise<void>> evalAsync(const std::shared_ptr<HybridStringBuilderSpec>& jscript, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) override;
+  void consoleOutputSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void callFunction(const std::shared_ptr<HybridJsonObjectSpec>& funcJson, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) override;
+  std::shared_ptr<Promise<void>> callFunctionAsync(const std::shared_ptr<HybridJsonObjectSpec>& funcJson, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) override;
+  void setCkPermission(const std::string& chilkatClassName, const std::string& permission) override;
+
+  // ---- Events (ReactNativeGen_DESIGN.md §6) ----
+  std::optional<std::function<void(double)>> getOnPercentDone() override;
+  void setOnPercentDone(const std::optional<std::function<void(double)>>& cb) override;
+  std::optional<std::function<void(const std::string&, const std::string&)>> getOnProgressInfo() override;
+  void setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) override;
+  void abort() override;
+
+private:
+  void init();
+  void eval_impl(const std::shared_ptr<HybridStringBuilderSpec>& jscript, const std::shared_ptr<HybridJsonObjectSpec>& resultJson);
+  void consoleOutputSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void callFunction_impl(const std::shared_ptr<HybridJsonObjectSpec>& funcJson, const std::shared_ptr<HybridJsonObjectSpec>& resultJson);
+  void setCkPermission_impl(const std::string& chilkatClassName, const std::string& permission);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridJsonArray.cpp

@@ -0,0 +1,441 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridJsonArray.hpp"
+#include "HybridCkDateTime.hpp"
+#include "HybridDtObj.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridJsonArray::HybridJsonArray()
+    : HybridObject(HybridJsonArraySpec::TAG), ChilkatObject<CkJsonArray>("JsonArray", CkJsonArray::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridJsonArray::HybridJsonArray(CkJsonArray* owned)
+    : HybridObject(HybridJsonArraySpec::TAG), ChilkatObject<CkJsonArray>("JsonArray", owned) {
+  init();
+}
+
+void HybridJsonArray::init() {
+}
+
+void HybridJsonArray::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridJsonArray::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJsonArray::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJsonArray::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJsonArray::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJsonArray::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridJsonArray::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridJsonArray::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridJsonArray::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridJsonArray::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridJsonArray::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridJsonArray::getSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Size());
+}
+bool HybridJsonArray::getEmitCrlf() {
+  this->beginCall();
+  return this->ck().get_EmitCrlf();
+}
+void HybridJsonArray::setEmitCrlf(bool value) {
+  this->beginCall();
+  this->ck().put_EmitCrlf(value);
+}
+bool HybridJsonArray::getEmitCompact() {
+  this->beginCall();
+  return this->ck().get_EmitCompact();
+}
+void HybridJsonArray::setEmitCompact(bool value) {
+  this->beginCall();
+  this->ck().put_EmitCompact(value);
+}
+double HybridJsonArray::getFindStartIndex() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_FindStartIndex());
+}
+void HybridJsonArray::setFindStartIndex(double value) {
+  this->beginCall();
+  this->ck().put_FindStartIndex(rt::toInt(value, "findStartIndex"));
+}
+
+// ---- Methods ----
+
+void HybridJsonArray::addArrayAt(double index) {
+  this->beginCall();
+  addArrayAt_impl(index);
+}
+void HybridJsonArray::addArrayAt_impl(double index) {
+  if (!this->ck().AddArrayAt(rt::toInt(index, "index"))) throw this->fail("addArrayAt");
+}
+
+void HybridJsonArray::addBoolAt(double index, bool value) {
+  this->beginCall();
+  addBoolAt_impl(index, value);
+}
+void HybridJsonArray::addBoolAt_impl(double index, bool value) {
+  if (!this->ck().AddBoolAt(rt::toInt(index, "index"), value)) throw this->fail("addBoolAt");
+}
+
+void HybridJsonArray::addIntAt(double index, double value) {
+  this->beginCall();
+  addIntAt_impl(index, value);
+}
+void HybridJsonArray::addIntAt_impl(double index, double value) {
+  if (!this->ck().AddIntAt(rt::toInt(index, "index"), rt::toInt(value, "value"))) throw this->fail("addIntAt");
+}
+
+void HybridJsonArray::addNullAt(double index) {
+  this->beginCall();
+  addNullAt_impl(index);
+}
+void HybridJsonArray::addNullAt_impl(double index) {
+  if (!this->ck().AddNullAt(rt::toInt(index, "index"))) throw this->fail("addNullAt");
+}
+
+void HybridJsonArray::addNumberAt(double index, const std::string& numericStr) {
+  this->beginCall();
+  addNumberAt_impl(index, numericStr);
+}
+void HybridJsonArray::addNumberAt_impl(double index, const std::string& numericStr) {
+  rt::checkNoNul(numericStr, "numericStr");
+  if (!this->ck().AddNumberAt(rt::toInt(index, "index"), numericStr.c_str())) throw this->fail("addNumberAt");
+}
+
+void HybridJsonArray::addObjectAt(double index) {
+  this->beginCall();
+  addObjectAt_impl(index);
+}
+void HybridJsonArray::addObjectAt_impl(double index) {
+  if (!this->ck().AddObjectAt(rt::toInt(index, "index"))) throw this->fail("addObjectAt");
+}
+
+void HybridJsonArray::addStringAt(double index, const std::string& value) {
+  this->beginCall();
+  addStringAt_impl(index, value);
+}
+void HybridJsonArray::addStringAt_impl(double index, const std::string& value) {
+  rt::checkNoNul(value, "value");
+  if (!this->ck().AddStringAt(rt::toInt(index, "index"), value.c_str())) throw this->fail("addStringAt");
+}
+
+std::shared_ptr<HybridJsonArraySpec> HybridJsonArray::arrayAt(double index) {
+  this->beginCall();
+  return arrayAt_impl(index);
+}
+std::shared_ptr<HybridJsonArraySpec> HybridJsonArray::arrayAt_impl(double index) {
+  CkJsonArray* _r = this->ck().ArrayAt(rt::toInt(index, "index"));
+  if (!_r) throw this->fail("arrayAt");
+  return std::make_shared<HybridJsonArray>(_r);
+}
+
+bool HybridJsonArray::boolAt(double index) {
+  this->beginCall();
+  return boolAt_impl(index);
+}
+bool HybridJsonArray::boolAt_impl(double index) {
+  return this->ck().BoolAt(rt::toInt(index, "index"));
+}
+
+void HybridJsonArray::deleteAt(double index) {
+  this->beginCall();
+  deleteAt_impl(index);
+}
+void HybridJsonArray::deleteAt_impl(double index) {
+  if (!this->ck().DeleteAt(rt::toInt(index, "index"))) throw this->fail("deleteAt");
+}
+
+double HybridJsonArray::intAt(double index) {
+  this->beginCall();
+  return intAt_impl(index);
+}
+double HybridJsonArray::intAt_impl(double index) {
+  return static_cast<double>(this->ck().IntAt(rt::toInt(index, "index")));
+}
+
+bool HybridJsonArray::isNullAt(double index) {
+  this->beginCall();
+  return isNullAt_impl(index);
+}
+bool HybridJsonArray::isNullAt_impl(double index) {
+  return this->ck().IsNullAt(rt::toInt(index, "index"));
+}
+
+std::shared_ptr<HybridJsonObjectSpec> HybridJsonArray::objectAt(double index) {
+  this->beginCall();
+  return objectAt_impl(index);
+}
+std::shared_ptr<HybridJsonObjectSpec> HybridJsonArray::objectAt_impl(double index) {
+  CkJsonObject* _r = this->ck().ObjectAt(rt::toInt(index, "index"));
+  if (!_r) throw this->fail("objectAt");
+  return std::make_shared<HybridJsonObject>(_r);
+}
+
+void HybridJsonArray::setBoolAt(double index, bool value) {
+  this->beginCall();
+  setBoolAt_impl(index, value);
+}
+void HybridJsonArray::setBoolAt_impl(double index, bool value) {
+  if (!this->ck().SetBoolAt(rt::toInt(index, "index"), value)) throw this->fail("setBoolAt");
+}
+
+void HybridJsonArray::setIntAt(double index, double value) {
+  this->beginCall();
+  setIntAt_impl(index, value);
+}
+void HybridJsonArray::setIntAt_impl(double index, double value) {
+  if (!this->ck().SetIntAt(rt::toInt(index, "index"), rt::toInt(value, "value"))) throw this->fail("setIntAt");
+}
+
+void HybridJsonArray::setNullAt(double index) {
+  this->beginCall();
+  setNullAt_impl(index);
+}
+void HybridJsonArray::setNullAt_impl(double index) {
+  if (!this->ck().SetNullAt(rt::toInt(index, "index"))) throw this->fail("setNullAt");
+}
+
+void HybridJsonArray::setNumberAt(double index, const std::string& value) {
+  this->beginCall();
+  setNumberAt_impl(index, value);
+}
+void HybridJsonArray::setNumberAt_impl(double index, const std::string& value) {
+  rt::checkNoNul(value, "value");
+  if (!this->ck().SetNumberAt(rt::toInt(index, "index"), value.c_str())) throw this->fail("setNumberAt");
+}
+
+void HybridJsonArray::setStringAt(double index, const std::string& value) {
+  this->beginCall();
+  setStringAt_impl(index, value);
+}
+void HybridJsonArray::setStringAt_impl(double index, const std::string& value) {
+  rt::checkNoNul(value, "value");
+  if (!this->ck().SetStringAt(rt::toInt(index, "index"), value.c_str())) throw this->fail("setStringAt");
+}
+
+std::string HybridJsonArray::stringAt(double index) {
+  this->beginCall();
+  return stringAt_impl(index);
+}
+std::string HybridJsonArray::stringAt_impl(double index) {
+  CkString _out;
+  if (!this->ck().StringAt(rt::toInt(index, "index"), _out)) throw this->fail("stringAt");
+  return rt::stdString(_out);
+}
+
+std::string HybridJsonArray::emit() {
+  this->beginCall();
+  return emit_impl();
+}
+std::string HybridJsonArray::emit_impl() {
+  CkString _out;
+  if (!this->ck().Emit(_out)) throw this->fail("emit");
+  return rt::stdString(_out);
+}
+
+double HybridJsonArray::typeAt(double index) {
+  this->beginCall();
+  return typeAt_impl(index);
+}
+double HybridJsonArray::typeAt_impl(double index) {
+  return static_cast<double>(this->ck().TypeAt(rt::toInt(index, "index")));
+}
+
+void HybridJsonArray::loadSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  loadSb_impl(sb);
+}
+void HybridJsonArray::loadSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().LoadSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("loadSb");
+}
+
+void HybridJsonArray::load(const std::string& jsonArray) {
+  this->beginCall();
+  load_impl(jsonArray);
+}
+void HybridJsonArray::load_impl(const std::string& jsonArray) {
+  rt::checkNoNul(jsonArray, "jsonArray");
+  if (!this->ck().Load(jsonArray.c_str())) throw this->fail("load");
+}
+
+void HybridJsonArray::emitSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  emitSb_impl(sb);
+}
+void HybridJsonArray::emitSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().EmitSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("emitSb");
+}
+
+void HybridJsonArray::dateAt(double index, const std::shared_ptr<HybridCkDateTimeSpec>& dt) {
+  this->beginCall();
+  dateAt_impl(index, dt);
+}
+void HybridJsonArray::dateAt_impl(double index, const std::shared_ptr<HybridCkDateTimeSpec>& dt) {
+  if (!this->ck().DateAt(rt::toInt(index, "index"), rt::implOf<HybridCkDateTime>(dt, "dt").ck())) throw this->fail("dateAt");
+}
+
+void HybridJsonArray::dtAt(double index, bool bLocal, const std::shared_ptr<HybridDtObjSpec>& dt) {
+  this->beginCall();
+  dtAt_impl(index, bLocal, dt);
+}
+void HybridJsonArray::dtAt_impl(double index, bool bLocal, const std::shared_ptr<HybridDtObjSpec>& dt) {
+  if (!this->ck().DtAt(rt::toInt(index, "index"), bLocal, rt::implOf<HybridDtObj>(dt, "dt").ck())) throw this->fail("dtAt");
+}
+
+double HybridJsonArray::findString(const std::string& value, bool caseSensitive) {
+  this->beginCall();
+  return findString_impl(value, caseSensitive);
+}
+double HybridJsonArray::findString_impl(const std::string& value, bool caseSensitive) {
+  rt::checkNoNul(value, "value");
+  return static_cast<double>(this->ck().FindString(value.c_str(), caseSensitive));
+}
+
+double HybridJsonArray::findObject(const std::string& name, const std::string& value, bool caseSensitive) {
+  this->beginCall();
+  return findObject_impl(name, value, caseSensitive);
+}
+double HybridJsonArray::findObject_impl(const std::string& name, const std::string& value, bool caseSensitive) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  return static_cast<double>(this->ck().FindObject(name.c_str(), value.c_str(), caseSensitive));
+}
+
+void HybridJsonArray::swap(double index1, double index2) {
+  this->beginCall();
+  swap_impl(index1, index2);
+}
+void HybridJsonArray::swap_impl(double index1, double index2) {
+  if (!this->ck().Swap(rt::toInt(index1, "index1"), rt::toInt(index2, "index2"))) throw this->fail("swap");
+}
+
+void HybridJsonArray::clear() {
+  this->beginCall();
+  clear_impl();
+}
+void HybridJsonArray::clear_impl() {
+  this->ck().Clear();
+}
+
+void HybridJsonArray::appendArrayItems(const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  this->beginCall();
+  appendArrayItems_impl(jarr);
+}
+void HybridJsonArray::appendArrayItems_impl(const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  if (!this->ck().AppendArrayItems(rt::implOf<HybridJsonArray>(jarr, "jarr").ck())) throw this->fail("appendArrayItems");
+}
+
+void HybridJsonArray::addObjectCopyAt(double index, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  this->beginCall();
+  addObjectCopyAt_impl(index, jsonObj);
+}
+void HybridJsonArray::addObjectCopyAt_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  if (!this->ck().AddObjectCopyAt(rt::toInt(index, "index"), rt::implOf<HybridJsonObject>(jsonObj, "jsonObj").ck())) throw this->fail("addObjectCopyAt");
+}
+
+double HybridJsonArray::uIntAt(double index) {
+  this->beginCall();
+  return uIntAt_impl(index);
+}
+double HybridJsonArray::uIntAt_impl(double index) {
+  return static_cast<double>(this->ck().UIntAt(rt::toInt(index, "index")));
+}
+
+void HybridJsonArray::addUIntAt(double index, double value) {
+  this->beginCall();
+  addUIntAt_impl(index, value);
+}
+void HybridJsonArray::addUIntAt_impl(double index, double value) {
+  if (!this->ck().AddUIntAt(rt::toInt(index, "index"), rt::toULong(value, "value"))) throw this->fail("addUIntAt");
+}
+
+void HybridJsonArray::setUIntAt(double index, double value) {
+  this->beginCall();
+  setUIntAt_impl(index, value);
+}
+void HybridJsonArray::setUIntAt_impl(double index, double value) {
+  if (!this->ck().SetUIntAt(rt::toInt(index, "index"), rt::toULong(value, "value"))) throw this->fail("setUIntAt");
+}
+
+void HybridJsonArray::arrayAt2(double index, const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  this->beginCall();
+  arrayAt2_impl(index, jarr);
+}
+void HybridJsonArray::arrayAt2_impl(double index, const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  if (!this->ck().ArrayAt2(rt::toInt(index, "index"), rt::implOf<HybridJsonArray>(jarr, "jarr").ck())) throw this->fail("arrayAt2");
+}
+
+void HybridJsonArray::objectAt2(double index, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  this->beginCall();
+  objectAt2_impl(index, jsonObj);
+}
+void HybridJsonArray::objectAt2_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  if (!this->ck().ObjectAt2(rt::toInt(index, "index"), rt::implOf<HybridJsonObject>(jsonObj, "jsonObj").ck())) throw this->fail("objectAt2");
+}
+
+void HybridJsonArray::addArrayAt2(double index, const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  this->beginCall();
+  addArrayAt2_impl(index, jarr);
+}
+void HybridJsonArray::addArrayAt2_impl(double index, const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  if (!this->ck().AddArrayAt2(rt::toInt(index, "index"), rt::implOf<HybridJsonArray>(jarr, "jarr").ck())) throw this->fail("addArrayAt2");
+}
+
+void HybridJsonArray::addObjectAt2(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  addObjectAt2_impl(index, json);
+}
+void HybridJsonArray::addObjectAt2_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().AddObjectAt2(rt::toInt(index, "index"), rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("addObjectAt2");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridJsonArray.hpp

@@ -0,0 +1,120 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// JsonArray: the Nitro HybridObject over Chilkat's CkJsonArray (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridJsonArraySpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkJsonArray.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridJsonArray final : public HybridJsonArraySpec, public ChilkatObject<CkJsonArray> {
+public:
+  HybridJsonArray();                                  // `new JsonArray()` from JS
+  explicit HybridJsonArray(CkJsonArray* 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 getSize() override;
+  bool getEmitCrlf() override;
+  void setEmitCrlf(bool value) override;
+  bool getEmitCompact() override;
+  void setEmitCompact(bool value) override;
+  double getFindStartIndex() override;
+  void setFindStartIndex(double value) override;
+
+  // ---- Methods ----
+  void addArrayAt(double index) override;
+  void addBoolAt(double index, bool value) override;
+  void addIntAt(double index, double value) override;
+  void addNullAt(double index) override;
+  void addNumberAt(double index, const std::string& numericStr) override;
+  void addObjectAt(double index) override;
+  void addStringAt(double index, const std::string& value) override;
+  std::shared_ptr<HybridJsonArraySpec> arrayAt(double index) override;
+  bool boolAt(double index) override;
+  void deleteAt(double index) override;
+  double intAt(double index) override;
+  bool isNullAt(double index) override;
+  std::shared_ptr<HybridJsonObjectSpec> objectAt(double index) override;
+  void setBoolAt(double index, bool value) override;
+  void setIntAt(double index, double value) override;
+  void setNullAt(double index) override;
+  void setNumberAt(double index, const std::string& value) override;
+  void setStringAt(double index, const std::string& value) override;
+  std::string stringAt(double index) override;
+  std::string emit() override;
+  double typeAt(double index) override;
+  void loadSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void load(const std::string& jsonArray) override;
+  void emitSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void dateAt(double index, const std::shared_ptr<HybridCkDateTimeSpec>& dt) override;
+  void dtAt(double index, bool bLocal, const std::shared_ptr<HybridDtObjSpec>& dt) override;
+  double findString(const std::string& value, bool caseSensitive) override;
+  double findObject(const std::string& name, const std::string& value, bool caseSensitive) override;
+  void swap(double index1, double index2) override;
+  void clear() override;
+  void appendArrayItems(const std::shared_ptr<HybridJsonArraySpec>& jarr) override;
+  void addObjectCopyAt(double index, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) override;
+  double uIntAt(double index) override;
+  void addUIntAt(double index, double value) override;
+  void setUIntAt(double index, double value) override;
+  void arrayAt2(double index, const std::shared_ptr<HybridJsonArraySpec>& jarr) override;
+  void objectAt2(double index, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) override;
+  void addArrayAt2(double index, const std::shared_ptr<HybridJsonArraySpec>& jarr) override;
+  void addObjectAt2(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+
+private:
+  void init();
+  void addArrayAt_impl(double index);
+  void addBoolAt_impl(double index, bool value);
+  void addIntAt_impl(double index, double value);
+  void addNullAt_impl(double index);
+  void addNumberAt_impl(double index, const std::string& numericStr);
+  void addObjectAt_impl(double index);
+  void addStringAt_impl(double index, const std::string& value);
+  std::shared_ptr<HybridJsonArraySpec> arrayAt_impl(double index);
+  bool boolAt_impl(double index);
+  void deleteAt_impl(double index);
+  double intAt_impl(double index);
+  bool isNullAt_impl(double index);
+  std::shared_ptr<HybridJsonObjectSpec> objectAt_impl(double index);
+  void setBoolAt_impl(double index, bool value);
+  void setIntAt_impl(double index, double value);
+  void setNullAt_impl(double index);
+  void setNumberAt_impl(double index, const std::string& value);
+  void setStringAt_impl(double index, const std::string& value);
+  std::string stringAt_impl(double index);
+  std::string emit_impl();
+  double typeAt_impl(double index);
+  void loadSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void load_impl(const std::string& jsonArray);
+  void emitSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void dateAt_impl(double index, const std::shared_ptr<HybridCkDateTimeSpec>& dt);
+  void dtAt_impl(double index, bool bLocal, const std::shared_ptr<HybridDtObjSpec>& dt);
+  double findString_impl(const std::string& value, bool caseSensitive);
+  double findObject_impl(const std::string& name, const std::string& value, bool caseSensitive);
+  void swap_impl(double index1, double index2);
+  void clear_impl();
+  void appendArrayItems_impl(const std::shared_ptr<HybridJsonArraySpec>& jarr);
+  void addObjectCopyAt_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj);
+  double uIntAt_impl(double index);
+  void addUIntAt_impl(double index, double value);
+  void setUIntAt_impl(double index, double value);
+  void arrayAt2_impl(double index, const std::shared_ptr<HybridJsonArraySpec>& jarr);
+  void objectAt2_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj);
+  void addArrayAt2_impl(double index, const std::shared_ptr<HybridJsonArraySpec>& jarr);
+  void addObjectAt2_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& json);
+};
+
+} // namespace margelo::nitro::chilkat