@chilkat/react-native 11.6.1

package/cpp/HybridJsonObject.cpp

@@ -0,0 +1,1125 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridJsonObject.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCkDateTime.hpp"
+#include "HybridDtObj.hpp"
+#include "HybridHashtable.hpp"
+#include "HybridJsonArray.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridStringTable.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridJsonObject::HybridJsonObject()
+    : HybridObject(HybridJsonObjectSpec::TAG), ChilkatObject<CkJsonObject>("JsonObject", CkJsonObject::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridJsonObject::HybridJsonObject(CkJsonObject* owned)
+    : HybridObject(HybridJsonObjectSpec::TAG), ChilkatObject<CkJsonObject>("JsonObject", owned) {
+  init();
+}
+
+void HybridJsonObject::init() {
+}
+
+void HybridJsonObject::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridJsonObject::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJsonObject::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJsonObject::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJsonObject::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJsonObject::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridJsonObject::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridJsonObject::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridJsonObject::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridJsonObject::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridJsonObject::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridJsonObject::getDelimiterChar() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DelimiterChar(_s);
+  return rt::stdString(_s);
+}
+void HybridJsonObject::setDelimiterChar(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "delimiterChar");
+  this->ck().put_DelimiterChar(value.c_str());
+}
+bool HybridJsonObject::getEmitCompact() {
+  this->beginCall();
+  return this->ck().get_EmitCompact();
+}
+void HybridJsonObject::setEmitCompact(bool value) {
+  this->beginCall();
+  this->ck().put_EmitCompact(value);
+}
+bool HybridJsonObject::getEmitCrLf() {
+  this->beginCall();
+  return this->ck().get_EmitCrLf();
+}
+void HybridJsonObject::setEmitCrLf(bool value) {
+  this->beginCall();
+  this->ck().put_EmitCrLf(value);
+}
+double HybridJsonObject::getI() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_I());
+}
+void HybridJsonObject::setI(double value) {
+  this->beginCall();
+  this->ck().put_I(rt::toInt(value, "i"));
+}
+double HybridJsonObject::getJ() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_J());
+}
+void HybridJsonObject::setJ(double value) {
+  this->beginCall();
+  this->ck().put_J(rt::toInt(value, "j"));
+}
+double HybridJsonObject::getK() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_K());
+}
+void HybridJsonObject::setK(double value) {
+  this->beginCall();
+  this->ck().put_K(rt::toInt(value, "k"));
+}
+double HybridJsonObject::getSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Size());
+}
+std::string HybridJsonObject::getPathPrefix() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_PathPrefix(_s);
+  return rt::stdString(_s);
+}
+void HybridJsonObject::setPathPrefix(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "pathPrefix");
+  this->ck().put_PathPrefix(value.c_str());
+}
+bool HybridJsonObject::getLowerCaseNames() {
+  this->beginCall();
+  return this->ck().get_LowerCaseNames();
+}
+void HybridJsonObject::setLowerCaseNames(bool value) {
+  this->beginCall();
+  this->ck().put_LowerCaseNames(value);
+}
+std::string HybridJsonObject::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridJsonObject::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+bool HybridJsonObject::getEnableSecrets() {
+  this->beginCall();
+  return this->ck().get_EnableSecrets();
+}
+void HybridJsonObject::setEnableSecrets(bool value) {
+  this->beginCall();
+  this->ck().put_EnableSecrets(value);
+}
+bool HybridJsonObject::getStrict() {
+  this->beginCall();
+  return this->ck().get_Strict();
+}
+void HybridJsonObject::setStrict(bool value) {
+  this->beginCall();
+  this->ck().put_Strict(value);
+}
+
+// ---- Methods ----
+
+void HybridJsonObject::addArrayAt(double index, const std::string& name) {
+  this->beginCall();
+  addArrayAt_impl(index, name);
+}
+void HybridJsonObject::addArrayAt_impl(double index, const std::string& name) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AddArrayAt(rt::toInt(index, "index"), name.c_str())) throw this->fail("addArrayAt");
+}
+
+void HybridJsonObject::addBoolAt(double index, const std::string& name, bool value) {
+  this->beginCall();
+  addBoolAt_impl(index, name, value);
+}
+void HybridJsonObject::addBoolAt_impl(double index, const std::string& name, bool value) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AddBoolAt(rt::toInt(index, "index"), name.c_str(), value)) throw this->fail("addBoolAt");
+}
+
+void HybridJsonObject::addIntAt(double index, const std::string& name, double value) {
+  this->beginCall();
+  addIntAt_impl(index, name, value);
+}
+void HybridJsonObject::addIntAt_impl(double index, const std::string& name, double value) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AddIntAt(rt::toInt(index, "index"), name.c_str(), rt::toInt(value, "value"))) throw this->fail("addIntAt");
+}
+
+void HybridJsonObject::addNullAt(double index, const std::string& name) {
+  this->beginCall();
+  addNullAt_impl(index, name);
+}
+void HybridJsonObject::addNullAt_impl(double index, const std::string& name) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AddNullAt(rt::toInt(index, "index"), name.c_str())) throw this->fail("addNullAt");
+}
+
+void HybridJsonObject::addNumberAt(double index, const std::string& name, const std::string& numericStr) {
+  this->beginCall();
+  addNumberAt_impl(index, name, numericStr);
+}
+void HybridJsonObject::addNumberAt_impl(double index, const std::string& name, const std::string& numericStr) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(numericStr, "numericStr");
+  if (!this->ck().AddNumberAt(rt::toInt(index, "index"), name.c_str(), numericStr.c_str())) throw this->fail("addNumberAt");
+}
+
+void HybridJsonObject::addObjectAt(double index, const std::string& name) {
+  this->beginCall();
+  addObjectAt_impl(index, name);
+}
+void HybridJsonObject::addObjectAt_impl(double index, const std::string& name) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AddObjectAt(rt::toInt(index, "index"), name.c_str())) throw this->fail("addObjectAt");
+}
+
+void HybridJsonObject::addStringAt(double index, const std::string& name, const std::string& value) {
+  this->beginCall();
+  addStringAt_impl(index, name, value);
+}
+void HybridJsonObject::addStringAt_impl(double index, const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().AddStringAt(rt::toInt(index, "index"), name.c_str(), value.c_str())) throw this->fail("addStringAt");
+}
+
+std::shared_ptr<HybridJsonArraySpec> HybridJsonObject::appendArray(const std::string& name) {
+  this->beginCall();
+  return appendArray_impl(name);
+}
+std::shared_ptr<HybridJsonArraySpec> HybridJsonObject::appendArray_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  CkJsonArray* _r = this->ck().AppendArray(name.c_str());
+  if (!_r) throw this->fail("appendArray");
+  return std::make_shared<HybridJsonArray>(_r);
+}
+
+void HybridJsonObject::appendBool(const std::string& name, bool value) {
+  this->beginCall();
+  appendBool_impl(name, value);
+}
+void HybridJsonObject::appendBool_impl(const std::string& name, bool value) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AppendBool(name.c_str(), value)) throw this->fail("appendBool");
+}
+
+void HybridJsonObject::appendInt(const std::string& name, double value) {
+  this->beginCall();
+  appendInt_impl(name, value);
+}
+void HybridJsonObject::appendInt_impl(const std::string& name, double value) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AppendInt(name.c_str(), rt::toInt(value, "value"))) throw this->fail("appendInt");
+}
+
+std::shared_ptr<HybridJsonObjectSpec> HybridJsonObject::appendObject(const std::string& name) {
+  this->beginCall();
+  return appendObject_impl(name);
+}
+std::shared_ptr<HybridJsonObjectSpec> HybridJsonObject::appendObject_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  CkJsonObject* _r = this->ck().AppendObject(name.c_str());
+  if (!_r) throw this->fail("appendObject");
+  return std::make_shared<HybridJsonObject>(_r);
+}
+
+void HybridJsonObject::appendString(const std::string& name, const std::string& value) {
+  this->beginCall();
+  appendString_impl(name, value);
+}
+void HybridJsonObject::appendString_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().AppendString(name.c_str(), value.c_str())) throw this->fail("appendString");
+}
+
+std::shared_ptr<HybridJsonArraySpec> HybridJsonObject::arrayAt(double index) {
+  this->beginCall();
+  return arrayAt_impl(index);
+}
+std::shared_ptr<HybridJsonArraySpec> HybridJsonObject::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);
+}
+
+std::shared_ptr<HybridJsonArraySpec> HybridJsonObject::arrayOf(const std::string& jsonPath) {
+  this->beginCall();
+  return arrayOf_impl(jsonPath);
+}
+std::shared_ptr<HybridJsonArraySpec> HybridJsonObject::arrayOf_impl(const std::string& jsonPath) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  CkJsonArray* _r = this->ck().ArrayOf(jsonPath.c_str());
+  if (!_r) throw this->fail("arrayOf");
+  return std::make_shared<HybridJsonArray>(_r);
+}
+
+bool HybridJsonObject::boolAt(double index) {
+  this->beginCall();
+  return boolAt_impl(index);
+}
+bool HybridJsonObject::boolAt_impl(double index) {
+  return this->ck().BoolAt(rt::toInt(index, "index"));
+}
+
+bool HybridJsonObject::boolOf(const std::string& jsonPath) {
+  this->beginCall();
+  return boolOf_impl(jsonPath);
+}
+bool HybridJsonObject::boolOf_impl(const std::string& jsonPath) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  return this->ck().BoolOf(jsonPath.c_str());
+}
+
+void HybridJsonObject::deleteMember(const std::string& name) {
+  this->beginCall();
+  deleteMember_impl(name);
+}
+void HybridJsonObject::deleteMember_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().Delete(name.c_str())) throw this->fail("deleteMember");
+}
+
+void HybridJsonObject::deleteAt(double index) {
+  this->beginCall();
+  deleteAt_impl(index);
+}
+void HybridJsonObject::deleteAt_impl(double index) {
+  if (!this->ck().DeleteAt(rt::toInt(index, "index"))) throw this->fail("deleteAt");
+}
+
+std::string HybridJsonObject::emit() {
+  this->beginCall();
+  return emit_impl();
+}
+std::string HybridJsonObject::emit_impl() {
+  CkString _out;
+  if (!this->ck().Emit(_out)) throw this->fail("emit");
+  return rt::stdString(_out);
+}
+
+void HybridJsonObject::firebaseApplyEvent(const std::string& name, const std::string& data) {
+  this->beginCall();
+  firebaseApplyEvent_impl(name, data);
+}
+void HybridJsonObject::firebaseApplyEvent_impl(const std::string& name, const std::string& data) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(data, "data");
+  if (!this->ck().FirebaseApplyEvent(name.c_str(), data.c_str())) throw this->fail("firebaseApplyEvent");
+}
+
+void HybridJsonObject::firebasePatch(const std::string& jsonPath, const std::string& jsonData) {
+  this->beginCall();
+  firebasePatch_impl(jsonPath, jsonData);
+}
+void HybridJsonObject::firebasePatch_impl(const std::string& jsonPath, const std::string& jsonData) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  rt::checkNoNul(jsonData, "jsonData");
+  if (!this->ck().FirebasePatch(jsonPath.c_str(), jsonData.c_str())) throw this->fail("firebasePatch");
+}
+
+void HybridJsonObject::firebasePut(const std::string& jsonPath, const std::string& value) {
+  this->beginCall();
+  firebasePut_impl(jsonPath, value);
+}
+void HybridJsonObject::firebasePut_impl(const std::string& jsonPath, const std::string& value) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().FirebasePut(jsonPath.c_str(), value.c_str())) throw this->fail("firebasePut");
+}
+
+std::shared_ptr<HybridJsonObjectSpec> HybridJsonObject::getDocRoot() {
+  this->beginCall();
+  return getDocRoot_impl();
+}
+std::shared_ptr<HybridJsonObjectSpec> HybridJsonObject::getDocRoot_impl() {
+  CkJsonObject* _r = this->ck().GetDocRoot();
+  if (!_r) throw this->fail("getDocRoot");
+  return std::make_shared<HybridJsonObject>(_r);
+}
+
+bool HybridJsonObject::hasMember(const std::string& jsonPath) {
+  this->beginCall();
+  return hasMember_impl(jsonPath);
+}
+bool HybridJsonObject::hasMember_impl(const std::string& jsonPath) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  return this->ck().HasMember(jsonPath.c_str());
+}
+
+double HybridJsonObject::indexOf(const std::string& name) {
+  this->beginCall();
+  return indexOf_impl(name);
+}
+double HybridJsonObject::indexOf_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  return static_cast<double>(this->ck().IndexOf(name.c_str()));
+}
+
+double HybridJsonObject::intAt(double index) {
+  this->beginCall();
+  return intAt_impl(index);
+}
+double HybridJsonObject::intAt_impl(double index) {
+  return static_cast<double>(this->ck().IntAt(rt::toInt(index, "index")));
+}
+
+double HybridJsonObject::intOf(const std::string& jsonPath) {
+  this->beginCall();
+  return intOf_impl(jsonPath);
+}
+double HybridJsonObject::intOf_impl(const std::string& jsonPath) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  return static_cast<double>(this->ck().IntOf(jsonPath.c_str()));
+}
+
+bool HybridJsonObject::isNullAt(double index) {
+  this->beginCall();
+  return isNullAt_impl(index);
+}
+bool HybridJsonObject::isNullAt_impl(double index) {
+  return this->ck().IsNullAt(rt::toInt(index, "index"));
+}
+
+bool HybridJsonObject::isNullOf(const std::string& jsonPath) {
+  this->beginCall();
+  return isNullOf_impl(jsonPath);
+}
+bool HybridJsonObject::isNullOf_impl(const std::string& jsonPath) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  return this->ck().IsNullOf(jsonPath.c_str());
+}
+
+void HybridJsonObject::load(const std::string& json) {
+  this->beginCall();
+  load_impl(json);
+}
+void HybridJsonObject::load_impl(const std::string& json) {
+  rt::checkNoNul(json, "json");
+  if (!this->ck().Load(json.c_str())) throw this->fail("load");
+}
+
+void HybridJsonObject::loadFile(const std::string& path) {
+  this->beginCall();
+  loadFile_impl(path);
+}
+void HybridJsonObject::loadFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().LoadFile(path.c_str())) throw this->fail("loadFile");
+}
+
+std::string HybridJsonObject::nameAt(double index) {
+  this->beginCall();
+  return nameAt_impl(index);
+}
+std::string HybridJsonObject::nameAt_impl(double index) {
+  CkString _out;
+  if (!this->ck().NameAt(rt::toInt(index, "index"), _out)) throw this->fail("nameAt");
+  return rt::stdString(_out);
+}
+
+std::shared_ptr<HybridJsonObjectSpec> HybridJsonObject::objectAt(double index) {
+  this->beginCall();
+  return objectAt_impl(index);
+}
+std::shared_ptr<HybridJsonObjectSpec> HybridJsonObject::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);
+}
+
+std::shared_ptr<HybridJsonObjectSpec> HybridJsonObject::objectOf(const std::string& jsonPath) {
+  this->beginCall();
+  return objectOf_impl(jsonPath);
+}
+std::shared_ptr<HybridJsonObjectSpec> HybridJsonObject::objectOf_impl(const std::string& jsonPath) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  CkJsonObject* _r = this->ck().ObjectOf(jsonPath.c_str());
+  if (!_r) throw this->fail("objectOf");
+  return std::make_shared<HybridJsonObject>(_r);
+}
+
+void HybridJsonObject::rename(const std::string& oldName, const std::string& newName) {
+  this->beginCall();
+  rename_impl(oldName, newName);
+}
+void HybridJsonObject::rename_impl(const std::string& oldName, const std::string& newName) {
+  rt::checkNoNul(oldName, "oldName");
+  rt::checkNoNul(newName, "newName");
+  if (!this->ck().Rename(oldName.c_str(), newName.c_str())) throw this->fail("rename");
+}
+
+void HybridJsonObject::renameAt(double index, const std::string& name) {
+  this->beginCall();
+  renameAt_impl(index, name);
+}
+void HybridJsonObject::renameAt_impl(double index, const std::string& name) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().RenameAt(rt::toInt(index, "index"), name.c_str())) throw this->fail("renameAt");
+}
+
+void HybridJsonObject::setBoolAt(double index, bool value) {
+  this->beginCall();
+  setBoolAt_impl(index, value);
+}
+void HybridJsonObject::setBoolAt_impl(double index, bool value) {
+  if (!this->ck().SetBoolAt(rt::toInt(index, "index"), value)) throw this->fail("setBoolAt");
+}
+
+void HybridJsonObject::setBoolOf(const std::string& jsonPath, bool value) {
+  this->beginCall();
+  setBoolOf_impl(jsonPath, value);
+}
+void HybridJsonObject::setBoolOf_impl(const std::string& jsonPath, bool value) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  if (!this->ck().SetBoolOf(jsonPath.c_str(), value)) throw this->fail("setBoolOf");
+}
+
+void HybridJsonObject::setIntAt(double index, double value) {
+  this->beginCall();
+  setIntAt_impl(index, value);
+}
+void HybridJsonObject::setIntAt_impl(double index, double value) {
+  if (!this->ck().SetIntAt(rt::toInt(index, "index"), rt::toInt(value, "value"))) throw this->fail("setIntAt");
+}
+
+void HybridJsonObject::setIntOf(const std::string& jsonPath, double value) {
+  this->beginCall();
+  setIntOf_impl(jsonPath, value);
+}
+void HybridJsonObject::setIntOf_impl(const std::string& jsonPath, double value) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  if (!this->ck().SetIntOf(jsonPath.c_str(), rt::toInt(value, "value"))) throw this->fail("setIntOf");
+}
+
+void HybridJsonObject::setNullAt(double index) {
+  this->beginCall();
+  setNullAt_impl(index);
+}
+void HybridJsonObject::setNullAt_impl(double index) {
+  if (!this->ck().SetNullAt(rt::toInt(index, "index"))) throw this->fail("setNullAt");
+}
+
+void HybridJsonObject::setNullOf(const std::string& jsonPath) {
+  this->beginCall();
+  setNullOf_impl(jsonPath);
+}
+void HybridJsonObject::setNullOf_impl(const std::string& jsonPath) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  if (!this->ck().SetNullOf(jsonPath.c_str())) throw this->fail("setNullOf");
+}
+
+void HybridJsonObject::setNumberAt(double index, const std::string& value) {
+  this->beginCall();
+  setNumberAt_impl(index, value);
+}
+void HybridJsonObject::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 HybridJsonObject::setNumberOf(const std::string& jsonPath, const std::string& value) {
+  this->beginCall();
+  setNumberOf_impl(jsonPath, value);
+}
+void HybridJsonObject::setNumberOf_impl(const std::string& jsonPath, const std::string& value) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().SetNumberOf(jsonPath.c_str(), value.c_str())) throw this->fail("setNumberOf");
+}
+
+void HybridJsonObject::setStringAt(double index, const std::string& value) {
+  this->beginCall();
+  setStringAt_impl(index, value);
+}
+void HybridJsonObject::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");
+}
+
+void HybridJsonObject::setStringOf(const std::string& jsonPath, const std::string& value) {
+  this->beginCall();
+  setStringOf_impl(jsonPath, value);
+}
+void HybridJsonObject::setStringOf_impl(const std::string& jsonPath, const std::string& value) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().SetStringOf(jsonPath.c_str(), value.c_str())) throw this->fail("setStringOf");
+}
+
+double HybridJsonObject::sizeOfArray(const std::string& jsonPath) {
+  this->beginCall();
+  return sizeOfArray_impl(jsonPath);
+}
+double HybridJsonObject::sizeOfArray_impl(const std::string& jsonPath) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  return static_cast<double>(this->ck().SizeOfArray(jsonPath.c_str()));
+}
+
+std::string HybridJsonObject::stringAt(double index) {
+  this->beginCall();
+  return stringAt_impl(index);
+}
+std::string HybridJsonObject::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 HybridJsonObject::stringOf(const std::string& jsonPath) {
+  this->beginCall();
+  return stringOf_impl(jsonPath);
+}
+std::string HybridJsonObject::stringOf_impl(const std::string& jsonPath) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  CkString _out;
+  if (!this->ck().StringOf(jsonPath.c_str(), _out)) throw this->fail("stringOf");
+  return rt::stdString(_out);
+}
+
+double HybridJsonObject::typeAt(double index) {
+  this->beginCall();
+  return typeAt_impl(index);
+}
+double HybridJsonObject::typeAt_impl(double index) {
+  return static_cast<double>(this->ck().TypeAt(rt::toInt(index, "index")));
+}
+
+void HybridJsonObject::loadSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  loadSb_impl(sb);
+}
+void HybridJsonObject::loadSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().LoadSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("loadSb");
+}
+
+void HybridJsonObject::emitSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  emitSb_impl(sb);
+}
+void HybridJsonObject::emitSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().EmitSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("emitSb");
+}
+
+void HybridJsonObject::updateString(const std::string& jsonPath, const std::string& value) {
+  this->beginCall();
+  updateString_impl(jsonPath, value);
+}
+void HybridJsonObject::updateString_impl(const std::string& jsonPath, const std::string& value) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().UpdateString(jsonPath.c_str(), value.c_str())) throw this->fail("updateString");
+}
+
+void HybridJsonObject::updateInt(const std::string& jsonPath, double value) {
+  this->beginCall();
+  updateInt_impl(jsonPath, value);
+}
+void HybridJsonObject::updateInt_impl(const std::string& jsonPath, double value) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  if (!this->ck().UpdateInt(jsonPath.c_str(), rt::toInt(value, "value"))) throw this->fail("updateInt");
+}
+
+void HybridJsonObject::updateBool(const std::string& jsonPath, bool value) {
+  this->beginCall();
+  updateBool_impl(jsonPath, value);
+}
+void HybridJsonObject::updateBool_impl(const std::string& jsonPath, bool value) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  if (!this->ck().UpdateBool(jsonPath.c_str(), value)) throw this->fail("updateBool");
+}
+
+std::shared_ptr<HybridJsonObjectSpec> HybridJsonObject::findRecord(const std::string& arrayPath, const std::string& relPath, const std::string& value, bool caseSensitive) {
+  this->beginCall();
+  return findRecord_impl(arrayPath, relPath, value, caseSensitive);
+}
+std::shared_ptr<HybridJsonObjectSpec> HybridJsonObject::findRecord_impl(const std::string& arrayPath, const std::string& relPath, const std::string& value, bool caseSensitive) {
+  rt::checkNoNul(arrayPath, "arrayPath");
+  rt::checkNoNul(relPath, "relPath");
+  rt::checkNoNul(value, "value");
+  CkJsonObject* _r = this->ck().FindRecord(arrayPath.c_str(), relPath.c_str(), value.c_str(), caseSensitive);
+  if (!_r) throw this->fail("findRecord");
+  return std::make_shared<HybridJsonObject>(_r);
+}
+
+std::string HybridJsonObject::findRecordString(const std::string& arrayPath, const std::string& relPath, const std::string& value, bool caseSensitive, const std::string& retRelPath) {
+  this->beginCall();
+  return findRecordString_impl(arrayPath, relPath, value, caseSensitive, retRelPath);
+}
+std::string HybridJsonObject::findRecordString_impl(const std::string& arrayPath, const std::string& relPath, const std::string& value, bool caseSensitive, const std::string& retRelPath) {
+  rt::checkNoNul(arrayPath, "arrayPath");
+  rt::checkNoNul(relPath, "relPath");
+  rt::checkNoNul(value, "value");
+  rt::checkNoNul(retRelPath, "retRelPath");
+  CkString _out;
+  if (!this->ck().FindRecordString(arrayPath.c_str(), relPath.c_str(), value.c_str(), caseSensitive, retRelPath.c_str(), _out)) throw this->fail("findRecordString");
+  return rt::stdString(_out);
+}
+
+void HybridJsonObject::updateNumber(const std::string& jsonPath, const std::string& numericStr) {
+  this->beginCall();
+  updateNumber_impl(jsonPath, numericStr);
+}
+void HybridJsonObject::updateNumber_impl(const std::string& jsonPath, const std::string& numericStr) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  rt::checkNoNul(numericStr, "numericStr");
+  if (!this->ck().UpdateNumber(jsonPath.c_str(), numericStr.c_str())) throw this->fail("updateNumber");
+}
+
+void HybridJsonObject::updateNull(const std::string& jsonPath) {
+  this->beginCall();
+  updateNull_impl(jsonPath);
+}
+void HybridJsonObject::updateNull_impl(const std::string& jsonPath) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  if (!this->ck().UpdateNull(jsonPath.c_str())) throw this->fail("updateNull");
+}
+
+std::string HybridJsonObject::emitWithSubs(const std::shared_ptr<HybridHashtableSpec>& subs, bool omitEmpty) {
+  this->beginCall();
+  return emitWithSubs_impl(subs, omitEmpty);
+}
+std::string HybridJsonObject::emitWithSubs_impl(const std::shared_ptr<HybridHashtableSpec>& subs, bool omitEmpty) {
+  CkString _out;
+  if (!this->ck().EmitWithSubs(rt::implOf<HybridHashtable>(subs, "subs").ck(), omitEmpty, _out)) throw this->fail("emitWithSubs");
+  return rt::stdString(_out);
+}
+
+void HybridJsonObject::predefine(const std::string& name) {
+  this->beginCall();
+  predefine_impl(name);
+}
+void HybridJsonObject::predefine_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().Predefine(name.c_str())) throw this->fail("predefine");
+}
+
+void HybridJsonObject::loadPredefined(const std::string& name) {
+  this->beginCall();
+  loadPredefined_impl(name);
+}
+void HybridJsonObject::loadPredefined_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().LoadPredefined(name.c_str())) throw this->fail("loadPredefined");
+}
+
+void HybridJsonObject::appendStringArray(const std::string& name, const std::shared_ptr<HybridStringTableSpec>& values) {
+  this->beginCall();
+  appendStringArray_impl(name, values);
+}
+void HybridJsonObject::appendStringArray_impl(const std::string& name, const std::shared_ptr<HybridStringTableSpec>& values) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AppendStringArray(name.c_str(), rt::implOf<HybridStringTable>(values, "values").ck())) throw this->fail("appendStringArray");
+}
+
+std::shared_ptr<HybridJsonObjectSpec> HybridJsonObject::findObjectWithMember(const std::string& name) {
+  this->beginCall();
+  return findObjectWithMember_impl(name);
+}
+std::shared_ptr<HybridJsonObjectSpec> HybridJsonObject::findObjectWithMember_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  CkJsonObject* _r = this->ck().FindObjectWithMember(name.c_str());
+  if (!_r) throw this->fail("findObjectWithMember");
+  return std::make_shared<HybridJsonObject>(_r);
+}
+
+double HybridJsonObject::jsonTypeOf(const std::string& jsonPath) {
+  this->beginCall();
+  return jsonTypeOf_impl(jsonPath);
+}
+double HybridJsonObject::jsonTypeOf_impl(const std::string& jsonPath) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  return static_cast<double>(this->ck().JsonTypeOf(jsonPath.c_str()));
+}
+
+void HybridJsonObject::stringOfSb(const std::string& jsonPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  stringOfSb_impl(jsonPath, sb);
+}
+void HybridJsonObject::stringOfSb_impl(const std::string& jsonPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  if (!this->ck().StringOfSb(jsonPath.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("stringOfSb");
+}
+
+void HybridJsonObject::bytesOf(const std::string& jsonPath, const std::string& encoding, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  bytesOf_impl(jsonPath, encoding, bd);
+}
+void HybridJsonObject::bytesOf_impl(const std::string& jsonPath, const std::string& encoding, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().BytesOf(jsonPath.c_str(), encoding.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("bytesOf");
+}
+
+void HybridJsonObject::updateSb(const std::string& jsonPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  updateSb_impl(jsonPath, sb);
+}
+void HybridJsonObject::updateSb_impl(const std::string& jsonPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  if (!this->ck().UpdateSb(jsonPath.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("updateSb");
+}
+
+void HybridJsonObject::updateBd(const std::string& jsonPath, const std::string& encoding, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  updateBd_impl(jsonPath, encoding, bd);
+}
+void HybridJsonObject::updateBd_impl(const std::string& jsonPath, const std::string& encoding, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().UpdateBd(jsonPath.c_str(), encoding.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("updateBd");
+}
+
+void HybridJsonObject::dateOf(const std::string& jsonPath, const std::shared_ptr<HybridCkDateTimeSpec>& dt) {
+  this->beginCall();
+  dateOf_impl(jsonPath, dt);
+}
+void HybridJsonObject::dateOf_impl(const std::string& jsonPath, const std::shared_ptr<HybridCkDateTimeSpec>& dt) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  if (!this->ck().DateOf(jsonPath.c_str(), rt::implOf<HybridCkDateTime>(dt, "dt").ck())) throw this->fail("dateOf");
+}
+
+void HybridJsonObject::dtOf(const std::string& jsonPath, bool bLocal, const std::shared_ptr<HybridDtObjSpec>& dt) {
+  this->beginCall();
+  dtOf_impl(jsonPath, bLocal, dt);
+}
+void HybridJsonObject::dtOf_impl(const std::string& jsonPath, bool bLocal, const std::shared_ptr<HybridDtObjSpec>& dt) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  if (!this->ck().DtOf(jsonPath.c_str(), bLocal, rt::implOf<HybridDtObj>(dt, "dt").ck())) throw this->fail("dtOf");
+}
+
+void HybridJsonObject::updateNewArray(const std::string& jsonPath) {
+  this->beginCall();
+  updateNewArray_impl(jsonPath);
+}
+void HybridJsonObject::updateNewArray_impl(const std::string& jsonPath) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  if (!this->ck().UpdateNewArray(jsonPath.c_str())) throw this->fail("updateNewArray");
+}
+
+void HybridJsonObject::updateNewObject(const std::string& jsonPath) {
+  this->beginCall();
+  updateNewObject_impl(jsonPath);
+}
+void HybridJsonObject::updateNewObject_impl(const std::string& jsonPath) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  if (!this->ck().UpdateNewObject(jsonPath.c_str())) throw this->fail("updateNewObject");
+}
+
+void HybridJsonObject::clear() {
+  this->beginCall();
+  clear_impl();
+}
+void HybridJsonObject::clear_impl() {
+  this->ck().Clear();
+}
+
+void HybridJsonObject::swap(double index1, double index2) {
+  this->beginCall();
+  swap_impl(index1, index2);
+}
+void HybridJsonObject::swap_impl(double index1, double index2) {
+  if (!this->ck().Swap(rt::toInt(index1, "index1"), rt::toInt(index2, "index2"))) throw this->fail("swap");
+}
+
+void HybridJsonObject::writeFile(const std::string& path) {
+  this->beginCall();
+  writeFile_impl(path);
+}
+void HybridJsonObject::writeFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().WriteFile(path.c_str())) throw this->fail("writeFile");
+}
+
+void HybridJsonObject::loadBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  loadBd_impl(bd);
+}
+void HybridJsonObject::loadBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().LoadBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("loadBd");
+}
+
+void HybridJsonObject::emitBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  emitBd_impl(bd);
+}
+void HybridJsonObject::emitBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().EmitBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("emitBd");
+}
+
+void HybridJsonObject::moveMember(double fromIndex, double toIndex) {
+  this->beginCall();
+  moveMember_impl(fromIndex, toIndex);
+}
+void HybridJsonObject::moveMember_impl(double fromIndex, double toIndex) {
+  if (!this->ck().MoveMember(rt::toInt(fromIndex, "fromIndex"), rt::toInt(toIndex, "toIndex"))) throw this->fail("moveMember");
+}
+
+void HybridJsonObject::addArrayCopyAt(double index, const std::string& name, const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  this->beginCall();
+  addArrayCopyAt_impl(index, name, jarr);
+}
+void HybridJsonObject::addArrayCopyAt_impl(double index, const std::string& name, const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AddArrayCopyAt(rt::toInt(index, "index"), name.c_str(), rt::implOf<HybridJsonArray>(jarr, "jarr").ck())) throw this->fail("addArrayCopyAt");
+}
+
+void HybridJsonObject::addObjectCopyAt(double index, const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  this->beginCall();
+  addObjectCopyAt_impl(index, name, jsonObj);
+}
+void HybridJsonObject::addObjectCopyAt_impl(double index, const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AddObjectCopyAt(rt::toInt(index, "index"), name.c_str(), rt::implOf<HybridJsonObject>(jsonObj, "jsonObj").ck())) throw this->fail("addObjectCopyAt");
+}
+
+void HybridJsonObject::appendArrayCopy(const std::string& name, const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  this->beginCall();
+  appendArrayCopy_impl(name, jarr);
+}
+void HybridJsonObject::appendArrayCopy_impl(const std::string& name, const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AppendArrayCopy(name.c_str(), rt::implOf<HybridJsonArray>(jarr, "jarr").ck())) throw this->fail("appendArrayCopy");
+}
+
+void HybridJsonObject::appendObjectCopy(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  this->beginCall();
+  appendObjectCopy_impl(name, jsonObj);
+}
+void HybridJsonObject::appendObjectCopy_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AppendObjectCopy(name.c_str(), rt::implOf<HybridJsonObject>(jsonObj, "jsonObj").ck())) throw this->fail("appendObjectCopy");
+}
+
+double HybridJsonObject::deleteRecords(const std::string& arrayPath, const std::string& relpath, const std::string& value, bool caseSensitive) {
+  this->beginCall();
+  return deleteRecords_impl(arrayPath, relpath, value, caseSensitive);
+}
+double HybridJsonObject::deleteRecords_impl(const std::string& arrayPath, const std::string& relpath, const std::string& value, bool caseSensitive) {
+  rt::checkNoNul(arrayPath, "arrayPath");
+  rt::checkNoNul(relpath, "relpath");
+  rt::checkNoNul(value, "value");
+  return static_cast<double>(this->ck().DeleteRecords(arrayPath.c_str(), relpath.c_str(), value.c_str(), caseSensitive));
+}
+
+void HybridJsonObject::updateUInt(const std::string& jsonPath, double value) {
+  this->beginCall();
+  updateUInt_impl(jsonPath, value);
+}
+void HybridJsonObject::updateUInt_impl(const std::string& jsonPath, double value) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  if (!this->ck().UpdateUInt(jsonPath.c_str(), rt::toULong(value, "value"))) throw this->fail("updateUInt");
+}
+
+double HybridJsonObject::uIntOf(const std::string& jsonPath) {
+  this->beginCall();
+  return uIntOf_impl(jsonPath);
+}
+double HybridJsonObject::uIntOf_impl(const std::string& jsonPath) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  return static_cast<double>(this->ck().UIntOf(jsonPath.c_str()));
+}
+
+bool HybridJsonObject::stringOfEquals(const std::string& jsonPath, const std::string& value, bool caseSensitive) {
+  this->beginCall();
+  return stringOfEquals_impl(jsonPath, value, caseSensitive);
+}
+bool HybridJsonObject::stringOfEquals_impl(const std::string& jsonPath, const std::string& value, bool caseSensitive) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  rt::checkNoNul(value, "value");
+  return this->ck().StringOfEquals(jsonPath.c_str(), value.c_str(), caseSensitive);
+}
+
+void HybridJsonObject::sort(bool ascending, bool caseSensitive) {
+  this->beginCall();
+  sort_impl(ascending, caseSensitive);
+}
+void HybridJsonObject::sort_impl(bool ascending, bool caseSensitive) {
+  this->ck().Sort(ascending, caseSensitive);
+}
+
+void HybridJsonObject::appendArray2(const std::string& name, const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  this->beginCall();
+  appendArray2_impl(name, jarr);
+}
+void HybridJsonObject::appendArray2_impl(const std::string& name, const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AppendArray2(name.c_str(), rt::implOf<HybridJsonArray>(jarr, "jarr").ck())) throw this->fail("appendArray2");
+}
+
+void HybridJsonObject::appendObject2(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  this->beginCall();
+  appendObject2_impl(name, jsonObj);
+}
+void HybridJsonObject::appendObject2_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AppendObject2(name.c_str(), rt::implOf<HybridJsonObject>(jsonObj, "jsonObj").ck())) throw this->fail("appendObject2");
+}
+
+void HybridJsonObject::arrayAt2(double index, const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  this->beginCall();
+  arrayAt2_impl(index, jarr);
+}
+void HybridJsonObject::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 HybridJsonObject::objectAt2(double index, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  this->beginCall();
+  objectAt2_impl(index, jsonObj);
+}
+void HybridJsonObject::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 HybridJsonObject::makeCopy(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  makeCopy_impl(json);
+}
+void HybridJsonObject::makeCopy_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().MakeCopy(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("makeCopy");
+}
+
+void HybridJsonObject::copyRef(const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  this->beginCall();
+  copyRef_impl(jsonObj);
+}
+void HybridJsonObject::copyRef_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  if (!this->ck().CopyRef(rt::implOf<HybridJsonObject>(jsonObj, "jsonObj").ck())) throw this->fail("copyRef");
+}
+
+void HybridJsonObject::findObjectWithMember2(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  this->beginCall();
+  findObjectWithMember2_impl(name, jsonObj);
+}
+void HybridJsonObject::findObjectWithMember2_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().FindObjectWithMember2(name.c_str(), rt::implOf<HybridJsonObject>(jsonObj, "jsonObj").ck())) throw this->fail("findObjectWithMember2");
+}
+
+void HybridJsonObject::findRecord2(const std::string& arrayPath, const std::string& relPath, const std::string& value, bool caseSensitive, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  this->beginCall();
+  findRecord2_impl(arrayPath, relPath, value, caseSensitive, jsonObj);
+}
+void HybridJsonObject::findRecord2_impl(const std::string& arrayPath, const std::string& relPath, const std::string& value, bool caseSensitive, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  rt::checkNoNul(arrayPath, "arrayPath");
+  rt::checkNoNul(relPath, "relPath");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().FindRecord2(arrayPath.c_str(), relPath.c_str(), value.c_str(), caseSensitive, rt::implOf<HybridJsonObject>(jsonObj, "jsonObj").ck())) throw this->fail("findRecord2");
+}
+
+void HybridJsonObject::getDocRoot2(const std::shared_ptr<HybridJsonObjectSpec>& docRoot) {
+  this->beginCall();
+  getDocRoot2_impl(docRoot);
+}
+void HybridJsonObject::getDocRoot2_impl(const std::shared_ptr<HybridJsonObjectSpec>& docRoot) {
+  if (!this->ck().GetDocRoot2(rt::implOf<HybridJsonObject>(docRoot, "docRoot").ck())) throw this->fail("getDocRoot2");
+}
+
+void HybridJsonObject::objectOf2(const std::string& jsonPath, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  this->beginCall();
+  objectOf2_impl(jsonPath, jsonObj);
+}
+void HybridJsonObject::objectOf2_impl(const std::string& jsonPath, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  if (!this->ck().ObjectOf2(jsonPath.c_str(), rt::implOf<HybridJsonObject>(jsonObj, "jsonObj").ck())) throw this->fail("objectOf2");
+}
+
+void HybridJsonObject::arrayOf2(const std::string& jsonPath, const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  this->beginCall();
+  arrayOf2_impl(jsonPath, jarr);
+}
+void HybridJsonObject::arrayOf2_impl(const std::string& jsonPath, const std::shared_ptr<HybridJsonArraySpec>& jarr) {
+  rt::checkNoNul(jsonPath, "jsonPath");
+  if (!this->ck().ArrayOf2(jsonPath.c_str(), rt::implOf<HybridJsonArray>(jarr, "jarr").ck())) throw this->fail("arrayOf2");
+}
+
+void HybridJsonObject::newObjectOf(const std::string& path, const std::string& jObj) {
+  this->beginCall();
+  newObjectOf_impl(path, jObj);
+}
+void HybridJsonObject::newObjectOf_impl(const std::string& path, const std::string& jObj) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(jObj, "jObj");
+  if (!this->ck().NewObjectOf(path.c_str(), jObj.c_str())) throw this->fail("newObjectOf");
+}
+
+void HybridJsonObject::newArrayOf(const std::string& path, const std::string& jArr) {
+  this->beginCall();
+  newArrayOf_impl(path, jArr);
+}
+void HybridJsonObject::newArrayOf_impl(const std::string& path, const std::string& jArr) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(jArr, "jArr");
+  if (!this->ck().NewArrayOf(path.c_str(), jArr.c_str())) throw this->fail("newArrayOf");
+}
+
+} // namespace margelo::nitro::chilkat