@chilkat/react-native 11.6.1

package/cpp/HybridJsonObject.hpp

@@ -0,0 +1,260 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// JsonObject: the Nitro HybridObject over Chilkat's CkJsonObject (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridJsonObjectSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkJsonObject.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridJsonObject final : public HybridJsonObjectSpec, public ChilkatObject<CkJsonObject> {
+public:
+  HybridJsonObject();                                  // `new JsonObject()` from JS
+  explicit HybridJsonObject(CkJsonObject* 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 getDelimiterChar() override;
+  void setDelimiterChar(const std::string& value) override;
+  bool getEmitCompact() override;
+  void setEmitCompact(bool value) override;
+  bool getEmitCrLf() override;
+  void setEmitCrLf(bool value) override;
+  double getI() override;
+  void setI(double value) override;
+  double getJ() override;
+  void setJ(double value) override;
+  double getK() override;
+  void setK(double value) override;
+  double getSize() override;
+  std::string getPathPrefix() override;
+  void setPathPrefix(const std::string& value) override;
+  bool getLowerCaseNames() override;
+  void setLowerCaseNames(bool value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+  bool getEnableSecrets() override;
+  void setEnableSecrets(bool value) override;
+  bool getStrict() override;
+  void setStrict(bool value) override;
+
+  // ---- Methods ----
+  void addArrayAt(double index, const std::string& name) override;
+  void addBoolAt(double index, const std::string& name, bool value) override;
+  void addIntAt(double index, const std::string& name, double value) override;
+  void addNullAt(double index, const std::string& name) override;
+  void addNumberAt(double index, const std::string& name, const std::string& numericStr) override;
+  void addObjectAt(double index, const std::string& name) override;
+  void addStringAt(double index, const std::string& name, const std::string& value) override;
+  std::shared_ptr<HybridJsonArraySpec> appendArray(const std::string& name) override;
+  void appendBool(const std::string& name, bool value) override;
+  void appendInt(const std::string& name, double value) override;
+  std::shared_ptr<HybridJsonObjectSpec> appendObject(const std::string& name) override;
+  void appendString(const std::string& name, const std::string& value) override;
+  std::shared_ptr<HybridJsonArraySpec> arrayAt(double index) override;
+  std::shared_ptr<HybridJsonArraySpec> arrayOf(const std::string& jsonPath) override;
+  bool boolAt(double index) override;
+  bool boolOf(const std::string& jsonPath) override;
+  void deleteMember(const std::string& name) override;
+  void deleteAt(double index) override;
+  std::string emit() override;
+  void firebaseApplyEvent(const std::string& name, const std::string& data) override;
+  void firebasePatch(const std::string& jsonPath, const std::string& jsonData) override;
+  void firebasePut(const std::string& jsonPath, const std::string& value) override;
+  std::shared_ptr<HybridJsonObjectSpec> getDocRoot() override;
+  bool hasMember(const std::string& jsonPath) override;
+  double indexOf(const std::string& name) override;
+  double intAt(double index) override;
+  double intOf(const std::string& jsonPath) override;
+  bool isNullAt(double index) override;
+  bool isNullOf(const std::string& jsonPath) override;
+  void load(const std::string& json) override;
+  void loadFile(const std::string& path) override;
+  std::string nameAt(double index) override;
+  std::shared_ptr<HybridJsonObjectSpec> objectAt(double index) override;
+  std::shared_ptr<HybridJsonObjectSpec> objectOf(const std::string& jsonPath) override;
+  void rename(const std::string& oldName, const std::string& newName) override;
+  void renameAt(double index, const std::string& name) override;
+  void setBoolAt(double index, bool value) override;
+  void setBoolOf(const std::string& jsonPath, bool value) override;
+  void setIntAt(double index, double value) override;
+  void setIntOf(const std::string& jsonPath, double value) override;
+  void setNullAt(double index) override;
+  void setNullOf(const std::string& jsonPath) override;
+  void setNumberAt(double index, const std::string& value) override;
+  void setNumberOf(const std::string& jsonPath, const std::string& value) override;
+  void setStringAt(double index, const std::string& value) override;
+  void setStringOf(const std::string& jsonPath, const std::string& value) override;
+  double sizeOfArray(const std::string& jsonPath) override;
+  std::string stringAt(double index) override;
+  std::string stringOf(const std::string& jsonPath) override;
+  double typeAt(double index) override;
+  void loadSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void emitSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void updateString(const std::string& jsonPath, const std::string& value) override;
+  void updateInt(const std::string& jsonPath, double value) override;
+  void updateBool(const std::string& jsonPath, bool value) override;
+  std::shared_ptr<HybridJsonObjectSpec> findRecord(const std::string& arrayPath, const std::string& relPath, const std::string& value, bool caseSensitive) override;
+  std::string findRecordString(const std::string& arrayPath, const std::string& relPath, const std::string& value, bool caseSensitive, const std::string& retRelPath) override;
+  void updateNumber(const std::string& jsonPath, const std::string& numericStr) override;
+  void updateNull(const std::string& jsonPath) override;
+  std::string emitWithSubs(const std::shared_ptr<HybridHashtableSpec>& subs, bool omitEmpty) override;
+  void predefine(const std::string& name) override;
+  void loadPredefined(const std::string& name) override;
+  void appendStringArray(const std::string& name, const std::shared_ptr<HybridStringTableSpec>& values) override;
+  std::shared_ptr<HybridJsonObjectSpec> findObjectWithMember(const std::string& name) override;
+  double jsonTypeOf(const std::string& jsonPath) override;
+  void stringOfSb(const std::string& jsonPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void bytesOf(const std::string& jsonPath, const std::string& encoding, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void updateSb(const std::string& jsonPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void updateBd(const std::string& jsonPath, const std::string& encoding, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void dateOf(const std::string& jsonPath, const std::shared_ptr<HybridCkDateTimeSpec>& dt) override;
+  void dtOf(const std::string& jsonPath, bool bLocal, const std::shared_ptr<HybridDtObjSpec>& dt) override;
+  void updateNewArray(const std::string& jsonPath) override;
+  void updateNewObject(const std::string& jsonPath) override;
+  void clear() override;
+  void swap(double index1, double index2) override;
+  void writeFile(const std::string& path) override;
+  void loadBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void emitBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void moveMember(double fromIndex, double toIndex) override;
+  void addArrayCopyAt(double index, const std::string& name, const std::shared_ptr<HybridJsonArraySpec>& jarr) override;
+  void addObjectCopyAt(double index, const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) override;
+  void appendArrayCopy(const std::string& name, const std::shared_ptr<HybridJsonArraySpec>& jarr) override;
+  void appendObjectCopy(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) override;
+  double deleteRecords(const std::string& arrayPath, const std::string& relpath, const std::string& value, bool caseSensitive) override;
+  void updateUInt(const std::string& jsonPath, double value) override;
+  double uIntOf(const std::string& jsonPath) override;
+  bool stringOfEquals(const std::string& jsonPath, const std::string& value, bool caseSensitive) override;
+  void sort(bool ascending, bool caseSensitive) override;
+  void appendArray2(const std::string& name, const std::shared_ptr<HybridJsonArraySpec>& jarr) override;
+  void appendObject2(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) override;
+  void arrayAt2(double index, const std::shared_ptr<HybridJsonArraySpec>& jarr) override;
+  void objectAt2(double index, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) override;
+  void makeCopy(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void copyRef(const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) override;
+  void findObjectWithMember2(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) override;
+  void findRecord2(const std::string& arrayPath, const std::string& relPath, const std::string& value, bool caseSensitive, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) override;
+  void getDocRoot2(const std::shared_ptr<HybridJsonObjectSpec>& docRoot) override;
+  void objectOf2(const std::string& jsonPath, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj) override;
+  void arrayOf2(const std::string& jsonPath, const std::shared_ptr<HybridJsonArraySpec>& jarr) override;
+  void newObjectOf(const std::string& path, const std::string& jObj) override;
+  void newArrayOf(const std::string& path, const std::string& jArr) override;
+
+private:
+  void init();
+  void addArrayAt_impl(double index, const std::string& name);
+  void addBoolAt_impl(double index, const std::string& name, bool value);
+  void addIntAt_impl(double index, const std::string& name, double value);
+  void addNullAt_impl(double index, const std::string& name);
+  void addNumberAt_impl(double index, const std::string& name, const std::string& numericStr);
+  void addObjectAt_impl(double index, const std::string& name);
+  void addStringAt_impl(double index, const std::string& name, const std::string& value);
+  std::shared_ptr<HybridJsonArraySpec> appendArray_impl(const std::string& name);
+  void appendBool_impl(const std::string& name, bool value);
+  void appendInt_impl(const std::string& name, double value);
+  std::shared_ptr<HybridJsonObjectSpec> appendObject_impl(const std::string& name);
+  void appendString_impl(const std::string& name, const std::string& value);
+  std::shared_ptr<HybridJsonArraySpec> arrayAt_impl(double index);
+  std::shared_ptr<HybridJsonArraySpec> arrayOf_impl(const std::string& jsonPath);
+  bool boolAt_impl(double index);
+  bool boolOf_impl(const std::string& jsonPath);
+  void deleteMember_impl(const std::string& name);
+  void deleteAt_impl(double index);
+  std::string emit_impl();
+  void firebaseApplyEvent_impl(const std::string& name, const std::string& data);
+  void firebasePatch_impl(const std::string& jsonPath, const std::string& jsonData);
+  void firebasePut_impl(const std::string& jsonPath, const std::string& value);
+  std::shared_ptr<HybridJsonObjectSpec> getDocRoot_impl();
+  bool hasMember_impl(const std::string& jsonPath);
+  double indexOf_impl(const std::string& name);
+  double intAt_impl(double index);
+  double intOf_impl(const std::string& jsonPath);
+  bool isNullAt_impl(double index);
+  bool isNullOf_impl(const std::string& jsonPath);
+  void load_impl(const std::string& json);
+  void loadFile_impl(const std::string& path);
+  std::string nameAt_impl(double index);
+  std::shared_ptr<HybridJsonObjectSpec> objectAt_impl(double index);
+  std::shared_ptr<HybridJsonObjectSpec> objectOf_impl(const std::string& jsonPath);
+  void rename_impl(const std::string& oldName, const std::string& newName);
+  void renameAt_impl(double index, const std::string& name);
+  void setBoolAt_impl(double index, bool value);
+  void setBoolOf_impl(const std::string& jsonPath, bool value);
+  void setIntAt_impl(double index, double value);
+  void setIntOf_impl(const std::string& jsonPath, double value);
+  void setNullAt_impl(double index);
+  void setNullOf_impl(const std::string& jsonPath);
+  void setNumberAt_impl(double index, const std::string& value);
+  void setNumberOf_impl(const std::string& jsonPath, const std::string& value);
+  void setStringAt_impl(double index, const std::string& value);
+  void setStringOf_impl(const std::string& jsonPath, const std::string& value);
+  double sizeOfArray_impl(const std::string& jsonPath);
+  std::string stringAt_impl(double index);
+  std::string stringOf_impl(const std::string& jsonPath);
+  double typeAt_impl(double index);
+  void loadSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void emitSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void updateString_impl(const std::string& jsonPath, const std::string& value);
+  void updateInt_impl(const std::string& jsonPath, double value);
+  void updateBool_impl(const std::string& jsonPath, bool value);
+  std::shared_ptr<HybridJsonObjectSpec> findRecord_impl(const std::string& arrayPath, const std::string& relPath, const std::string& value, bool caseSensitive);
+  std::string findRecordString_impl(const std::string& arrayPath, const std::string& relPath, const std::string& value, bool caseSensitive, const std::string& retRelPath);
+  void updateNumber_impl(const std::string& jsonPath, const std::string& numericStr);
+  void updateNull_impl(const std::string& jsonPath);
+  std::string emitWithSubs_impl(const std::shared_ptr<HybridHashtableSpec>& subs, bool omitEmpty);
+  void predefine_impl(const std::string& name);
+  void loadPredefined_impl(const std::string& name);
+  void appendStringArray_impl(const std::string& name, const std::shared_ptr<HybridStringTableSpec>& values);
+  std::shared_ptr<HybridJsonObjectSpec> findObjectWithMember_impl(const std::string& name);
+  double jsonTypeOf_impl(const std::string& jsonPath);
+  void stringOfSb_impl(const std::string& jsonPath, const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void bytesOf_impl(const std::string& jsonPath, const std::string& encoding, const std::shared_ptr<HybridBinDataSpec>& bd);
+  void updateSb_impl(const std::string& jsonPath, const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void updateBd_impl(const std::string& jsonPath, const std::string& encoding, const std::shared_ptr<HybridBinDataSpec>& bd);
+  void dateOf_impl(const std::string& jsonPath, const std::shared_ptr<HybridCkDateTimeSpec>& dt);
+  void dtOf_impl(const std::string& jsonPath, bool bLocal, const std::shared_ptr<HybridDtObjSpec>& dt);
+  void updateNewArray_impl(const std::string& jsonPath);
+  void updateNewObject_impl(const std::string& jsonPath);
+  void clear_impl();
+  void swap_impl(double index1, double index2);
+  void writeFile_impl(const std::string& path);
+  void loadBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  void emitBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  void moveMember_impl(double fromIndex, double toIndex);
+  void addArrayCopyAt_impl(double index, const std::string& name, const std::shared_ptr<HybridJsonArraySpec>& jarr);
+  void addObjectCopyAt_impl(double index, const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj);
+  void appendArrayCopy_impl(const std::string& name, const std::shared_ptr<HybridJsonArraySpec>& jarr);
+  void appendObjectCopy_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj);
+  double deleteRecords_impl(const std::string& arrayPath, const std::string& relpath, const std::string& value, bool caseSensitive);
+  void updateUInt_impl(const std::string& jsonPath, double value);
+  double uIntOf_impl(const std::string& jsonPath);
+  bool stringOfEquals_impl(const std::string& jsonPath, const std::string& value, bool caseSensitive);
+  void sort_impl(bool ascending, bool caseSensitive);
+  void appendArray2_impl(const std::string& name, const std::shared_ptr<HybridJsonArraySpec>& jarr);
+  void appendObject2_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj);
+  void arrayAt2_impl(double index, const std::shared_ptr<HybridJsonArraySpec>& jarr);
+  void objectAt2_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj);
+  void makeCopy_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void copyRef_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonObj);
+  void findObjectWithMember2_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj);
+  void findRecord2_impl(const std::string& arrayPath, const std::string& relPath, const std::string& value, bool caseSensitive, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj);
+  void getDocRoot2_impl(const std::shared_ptr<HybridJsonObjectSpec>& docRoot);
+  void objectOf2_impl(const std::string& jsonPath, const std::shared_ptr<HybridJsonObjectSpec>& jsonObj);
+  void arrayOf2_impl(const std::string& jsonPath, const std::shared_ptr<HybridJsonArraySpec>& jarr);
+  void newObjectOf_impl(const std::string& path, const std::string& jObj);
+  void newArrayOf_impl(const std::string& path, const std::string& jArr);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridJwe.cpp

@@ -0,0 +1,294 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridJwe.hpp"
+#include "HybridBinData.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridPrivateKey.hpp"
+#include "HybridPublicKey.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridJwe::HybridJwe()
+    : HybridObject(HybridJweSpec::TAG), ChilkatObject<CkJwe>("Jwe", CkJwe::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridJwe::HybridJwe(CkJwe* owned)
+    : HybridObject(HybridJweSpec::TAG), ChilkatObject<CkJwe>("Jwe", owned) {
+  init();
+}
+
+void HybridJwe::init() {
+}
+
+void HybridJwe::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridJwe::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJwe::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJwe::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJwe::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJwe::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridJwe::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridJwe::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridJwe::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridJwe::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridJwe::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridJwe::getNumRecipients() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumRecipients());
+}
+bool HybridJwe::getPreferCompact() {
+  this->beginCall();
+  return this->ck().get_PreferCompact();
+}
+void HybridJwe::setPreferCompact(bool value) {
+  this->beginCall();
+  this->ck().put_PreferCompact(value);
+}
+bool HybridJwe::getPreferFlattened() {
+  this->beginCall();
+  return this->ck().get_PreferFlattened();
+}
+void HybridJwe::setPreferFlattened(bool value) {
+  this->beginCall();
+  this->ck().put_PreferFlattened(value);
+}
+std::string HybridJwe::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridJwe::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridJwe::setProtectedHeader(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  setProtectedHeader_impl(json);
+}
+void HybridJwe::setProtectedHeader_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().SetProtectedHeader(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("setProtectedHeader");
+}
+
+void HybridJwe::setUnprotectedHeader(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  setUnprotectedHeader_impl(json);
+}
+void HybridJwe::setUnprotectedHeader_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().SetUnprotectedHeader(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("setUnprotectedHeader");
+}
+
+void HybridJwe::setRecipientHeader(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  setRecipientHeader_impl(index, json);
+}
+void HybridJwe::setRecipientHeader_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().SetRecipientHeader(rt::toInt(index, "index"), rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("setRecipientHeader");
+}
+
+void HybridJwe::setPrivateKey(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  setPrivateKey_impl(index, privKey);
+}
+void HybridJwe::setPrivateKey_impl(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  if (!this->ck().SetPrivateKey(rt::toInt(index, "index"), rt::implOf<HybridPrivateKey>(privKey, "privKey").ck())) throw this->fail("setPrivateKey");
+}
+
+void HybridJwe::setPublicKey(double index, const std::shared_ptr<HybridPublicKeySpec>& pubKey) {
+  this->beginCall();
+  setPublicKey_impl(index, pubKey);
+}
+void HybridJwe::setPublicKey_impl(double index, const std::shared_ptr<HybridPublicKeySpec>& pubKey) {
+  if (!this->ck().SetPublicKey(rt::toInt(index, "index"), rt::implOf<HybridPublicKey>(pubKey, "pubKey").ck())) throw this->fail("setPublicKey");
+}
+
+void HybridJwe::setWrappingKey(double index, const std::string& encodedKey, const std::string& encoding) {
+  this->beginCall();
+  setWrappingKey_impl(index, encodedKey, encoding);
+}
+void HybridJwe::setWrappingKey_impl(double index, const std::string& encodedKey, const std::string& encoding) {
+  rt::checkNoNul(encodedKey, "encodedKey");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().SetWrappingKey(rt::toInt(index, "index"), encodedKey.c_str(), encoding.c_str())) throw this->fail("setWrappingKey");
+}
+
+void HybridJwe::setPassword(double index, const std::string& password) {
+  this->beginCall();
+  setPassword_impl(index, password);
+}
+void HybridJwe::setPassword_impl(double index, const std::string& password) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().SetPassword(rt::toInt(index, "index"), password.c_str())) throw this->fail("setPassword");
+}
+
+std::string HybridJwe::encrypt(const std::string& content, const std::string& charset) {
+  this->beginCall();
+  return encrypt_impl(content, charset);
+}
+std::string HybridJwe::encrypt_impl(const std::string& content, const std::string& charset) {
+  rt::checkNoNul(content, "content");
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().Encrypt(content.c_str(), charset.c_str(), _out)) throw this->fail("encrypt");
+  return rt::stdString(_out);
+}
+
+void HybridJwe::encryptSb(const std::shared_ptr<HybridStringBuilderSpec>& contentSb, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& jweSb) {
+  this->beginCall();
+  encryptSb_impl(contentSb, charset, jweSb);
+}
+void HybridJwe::encryptSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& contentSb, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& jweSb) {
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().EncryptSb(rt::implOf<HybridStringBuilder>(contentSb, "contentSb").ck(), charset.c_str(), rt::implOf<HybridStringBuilder>(jweSb, "jweSb").ck())) throw this->fail("encryptSb");
+}
+
+void HybridJwe::encryptBd(const std::shared_ptr<HybridBinDataSpec>& contentBd, const std::shared_ptr<HybridStringBuilderSpec>& jweSb) {
+  this->beginCall();
+  encryptBd_impl(contentBd, jweSb);
+}
+void HybridJwe::encryptBd_impl(const std::shared_ptr<HybridBinDataSpec>& contentBd, const std::shared_ptr<HybridStringBuilderSpec>& jweSb) {
+  if (!this->ck().EncryptBd(rt::implOf<HybridBinData>(contentBd, "contentBd").ck(), rt::implOf<HybridStringBuilder>(jweSb, "jweSb").ck())) throw this->fail("encryptBd");
+}
+
+std::string HybridJwe::decrypt(double index, const std::string& charset) {
+  this->beginCall();
+  return decrypt_impl(index, charset);
+}
+std::string HybridJwe::decrypt_impl(double index, const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().Decrypt(rt::toInt(index, "index"), charset.c_str(), _out)) throw this->fail("decrypt");
+  return rt::stdString(_out);
+}
+
+void HybridJwe::decryptSb(double index, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& contentSb) {
+  this->beginCall();
+  decryptSb_impl(index, charset, contentSb);
+}
+void HybridJwe::decryptSb_impl(double index, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& contentSb) {
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().DecryptSb(rt::toInt(index, "index"), charset.c_str(), rt::implOf<HybridStringBuilder>(contentSb, "contentSb").ck())) throw this->fail("decryptSb");
+}
+
+void HybridJwe::decryptBd(double index, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  decryptBd_impl(index, bd);
+}
+void HybridJwe::decryptBd_impl(double index, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().DecryptBd(rt::toInt(index, "index"), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("decryptBd");
+}
+
+void HybridJwe::loadJwe(const std::string& jwe) {
+  this->beginCall();
+  loadJwe_impl(jwe);
+}
+void HybridJwe::loadJwe_impl(const std::string& jwe) {
+  rt::checkNoNul(jwe, "jwe");
+  if (!this->ck().LoadJwe(jwe.c_str())) throw this->fail("loadJwe");
+}
+
+void HybridJwe::loadJweSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  loadJweSb_impl(sb);
+}
+void HybridJwe::loadJweSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().LoadJweSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("loadJweSb");
+}
+
+void HybridJwe::setAad(const std::string& aad, const std::string& charset) {
+  this->beginCall();
+  setAad_impl(aad, charset);
+}
+void HybridJwe::setAad_impl(const std::string& aad, const std::string& charset) {
+  rt::checkNoNul(aad, "aad");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().SetAad(aad.c_str(), charset.c_str())) throw this->fail("setAad");
+}
+
+void HybridJwe::setAadBd(const std::shared_ptr<HybridBinDataSpec>& aad) {
+  this->beginCall();
+  setAadBd_impl(aad);
+}
+void HybridJwe::setAadBd_impl(const std::shared_ptr<HybridBinDataSpec>& aad) {
+  if (!this->ck().SetAadBd(rt::implOf<HybridBinData>(aad, "aad").ck())) throw this->fail("setAadBd");
+}
+
+double HybridJwe::findRecipient(const std::string& paramName, const std::string& paramValue, bool caseSensitive) {
+  this->beginCall();
+  return findRecipient_impl(paramName, paramValue, caseSensitive);
+}
+double HybridJwe::findRecipient_impl(const std::string& paramName, const std::string& paramValue, bool caseSensitive) {
+  rt::checkNoNul(paramName, "paramName");
+  rt::checkNoNul(paramValue, "paramValue");
+  return static_cast<double>(this->ck().FindRecipient(paramName.c_str(), paramValue.c_str(), caseSensitive));
+}
+
+void HybridJwe::getHeader(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getHeader_impl(json);
+}
+void HybridJwe::getHeader_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().GetHeader(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("getHeader");
+}
+
+void HybridJwe::getProtectedHeader(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getProtectedHeader_impl(json);
+}
+void HybridJwe::getProtectedHeader_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().GetProtectedHeader(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("getProtectedHeader");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridJwe.hpp

@@ -0,0 +1,82 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Jwe: the Nitro HybridObject over Chilkat's CkJwe (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridJweSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkJwe.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridJwe final : public HybridJweSpec, public ChilkatObject<CkJwe> {
+public:
+  HybridJwe();                                  // `new Jwe()` from JS
+  explicit HybridJwe(CkJwe* 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 getNumRecipients() override;
+  bool getPreferCompact() override;
+  void setPreferCompact(bool value) override;
+  bool getPreferFlattened() override;
+  void setPreferFlattened(bool value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+
+  // ---- Methods ----
+  void setProtectedHeader(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void setUnprotectedHeader(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void setRecipientHeader(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void setPrivateKey(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey) override;
+  void setPublicKey(double index, const std::shared_ptr<HybridPublicKeySpec>& pubKey) override;
+  void setWrappingKey(double index, const std::string& encodedKey, const std::string& encoding) override;
+  void setPassword(double index, const std::string& password) override;
+  std::string encrypt(const std::string& content, const std::string& charset) override;
+  void encryptSb(const std::shared_ptr<HybridStringBuilderSpec>& contentSb, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& jweSb) override;
+  void encryptBd(const std::shared_ptr<HybridBinDataSpec>& contentBd, const std::shared_ptr<HybridStringBuilderSpec>& jweSb) override;
+  std::string decrypt(double index, const std::string& charset) override;
+  void decryptSb(double index, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& contentSb) override;
+  void decryptBd(double index, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void loadJwe(const std::string& jwe) override;
+  void loadJweSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void setAad(const std::string& aad, const std::string& charset) override;
+  void setAadBd(const std::shared_ptr<HybridBinDataSpec>& aad) override;
+  double findRecipient(const std::string& paramName, const std::string& paramValue, bool caseSensitive) override;
+  void getHeader(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void getProtectedHeader(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+
+private:
+  void init();
+  void setProtectedHeader_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void setUnprotectedHeader_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void setRecipientHeader_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void setPrivateKey_impl(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey);
+  void setPublicKey_impl(double index, const std::shared_ptr<HybridPublicKeySpec>& pubKey);
+  void setWrappingKey_impl(double index, const std::string& encodedKey, const std::string& encoding);
+  void setPassword_impl(double index, const std::string& password);
+  std::string encrypt_impl(const std::string& content, const std::string& charset);
+  void encryptSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& contentSb, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& jweSb);
+  void encryptBd_impl(const std::shared_ptr<HybridBinDataSpec>& contentBd, const std::shared_ptr<HybridStringBuilderSpec>& jweSb);
+  std::string decrypt_impl(double index, const std::string& charset);
+  void decryptSb_impl(double index, const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& contentSb);
+  void decryptBd_impl(double index, const std::shared_ptr<HybridBinDataSpec>& bd);
+  void loadJwe_impl(const std::string& jwe);
+  void loadJweSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void setAad_impl(const std::string& aad, const std::string& charset);
+  void setAadBd_impl(const std::shared_ptr<HybridBinDataSpec>& aad);
+  double findRecipient_impl(const std::string& paramName, const std::string& paramValue, bool caseSensitive);
+  void getHeader_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void getProtectedHeader_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+};
+
+} // namespace margelo::nitro::chilkat