@chilkat/react-native 11.6.1

package/cpp/HybridDtObj.cpp

@@ -0,0 +1,172 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridDtObj.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridDtObj::HybridDtObj()
+    : HybridObject(HybridDtObjSpec::TAG), ChilkatObject<CkDtObj>("DtObj", CkDtObj::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridDtObj::HybridDtObj(CkDtObj* owned)
+    : HybridObject(HybridDtObjSpec::TAG), ChilkatObject<CkDtObj>("DtObj", owned) {
+  init();
+}
+
+void HybridDtObj::init() {
+}
+
+void HybridDtObj::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridDtObj::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDtObj::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDtObj::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDtObj::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDtObj::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridDtObj::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridDtObj::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridDtObj::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridDtObj::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridDtObj::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridDtObj::getDay() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Day());
+}
+void HybridDtObj::setDay(double value) {
+  this->beginCall();
+  this->ck().put_Day(rt::toInt(value, "day"));
+}
+double HybridDtObj::getHour() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Hour());
+}
+void HybridDtObj::setHour(double value) {
+  this->beginCall();
+  this->ck().put_Hour(rt::toInt(value, "hour"));
+}
+double HybridDtObj::getMinute() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Minute());
+}
+void HybridDtObj::setMinute(double value) {
+  this->beginCall();
+  this->ck().put_Minute(rt::toInt(value, "minute"));
+}
+double HybridDtObj::getMonth() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Month());
+}
+void HybridDtObj::setMonth(double value) {
+  this->beginCall();
+  this->ck().put_Month(rt::toInt(value, "month"));
+}
+double HybridDtObj::getSecond() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Second());
+}
+void HybridDtObj::setSecond(double value) {
+  this->beginCall();
+  this->ck().put_Second(rt::toInt(value, "second"));
+}
+double HybridDtObj::getStructTmMonth() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_StructTmMonth());
+}
+void HybridDtObj::setStructTmMonth(double value) {
+  this->beginCall();
+  this->ck().put_StructTmMonth(rt::toInt(value, "structTmMonth"));
+}
+double HybridDtObj::getStructTmYear() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_StructTmYear());
+}
+void HybridDtObj::setStructTmYear(double value) {
+  this->beginCall();
+  this->ck().put_StructTmYear(rt::toInt(value, "structTmYear"));
+}
+bool HybridDtObj::getUtc() {
+  this->beginCall();
+  return this->ck().get_Utc();
+}
+void HybridDtObj::setUtc(bool value) {
+  this->beginCall();
+  this->ck().put_Utc(value);
+}
+double HybridDtObj::getYear() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Year());
+}
+void HybridDtObj::setYear(double value) {
+  this->beginCall();
+  this->ck().put_Year(rt::toInt(value, "year"));
+}
+
+// ---- Methods ----
+
+void HybridDtObj::deSerialize(const std::string& serializedDtObj) {
+  this->beginCall();
+  deSerialize_impl(serializedDtObj);
+}
+void HybridDtObj::deSerialize_impl(const std::string& serializedDtObj) {
+  rt::checkNoNul(serializedDtObj, "serializedDtObj");
+  this->ck().DeSerialize(serializedDtObj.c_str());
+}
+
+std::string HybridDtObj::serialize() {
+  this->beginCall();
+  return serialize_impl();
+}
+std::string HybridDtObj::serialize_impl() {
+  CkString _out;
+  if (!this->ck().Serialize(_out)) throw this->fail("serialize");
+  return rt::stdString(_out);
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridDtObj.hpp

@@ -0,0 +1,57 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// DtObj: the Nitro HybridObject over Chilkat's CkDtObj (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridDtObjSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkDtObj.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridDtObj final : public HybridDtObjSpec, public ChilkatObject<CkDtObj> {
+public:
+  HybridDtObj();                                  // `new DtObj()` from JS
+  explicit HybridDtObj(CkDtObj* 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 getDay() override;
+  void setDay(double value) override;
+  double getHour() override;
+  void setHour(double value) override;
+  double getMinute() override;
+  void setMinute(double value) override;
+  double getMonth() override;
+  void setMonth(double value) override;
+  double getSecond() override;
+  void setSecond(double value) override;
+  double getStructTmMonth() override;
+  void setStructTmMonth(double value) override;
+  double getStructTmYear() override;
+  void setStructTmYear(double value) override;
+  bool getUtc() override;
+  void setUtc(bool value) override;
+  double getYear() override;
+  void setYear(double value) override;
+
+  // ---- Methods ----
+  void deSerialize(const std::string& serializedDtObj) override;
+  std::string serialize() override;
+
+private:
+  void init();
+  void deSerialize_impl(const std::string& serializedDtObj);
+  std::string serialize_impl();
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridEcc.cpp

@@ -0,0 +1,195 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridEcc.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCert.hpp"
+#include "HybridPrivateKey.hpp"
+#include "HybridPrng.hpp"
+#include "HybridPublicKey.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridEcc::HybridEcc()
+    : HybridObject(HybridEccSpec::TAG), ChilkatObject<CkEcc>("Ecc", CkEcc::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridEcc::HybridEcc(CkEcc* owned)
+    : HybridObject(HybridEccSpec::TAG), ChilkatObject<CkEcc>("Ecc", owned) {
+  init();
+}
+
+void HybridEcc::init() {
+}
+
+void HybridEcc::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridEcc::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEcc::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEcc::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEcc::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEcc::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridEcc::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridEcc::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridEcc::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridEcc::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridEcc::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridEcc::getAsnFormat() {
+  this->beginCall();
+  return this->ck().get_AsnFormat();
+}
+void HybridEcc::setAsnFormat(bool value) {
+  this->beginCall();
+  this->ck().put_AsnFormat(value);
+}
+
+// ---- Methods ----
+
+std::string HybridEcc::sharedSecretENC(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridPublicKeySpec>& pubKey, const std::string& encoding) {
+  this->beginCall();
+  return sharedSecretENC_impl(privKey, pubKey, encoding);
+}
+std::string HybridEcc::sharedSecretENC_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridPublicKeySpec>& pubKey, const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().SharedSecretENC(rt::implOf<HybridPrivateKey>(privKey, "privKey").ck(), rt::implOf<HybridPublicKey>(pubKey, "pubKey").ck(), encoding.c_str(), _out)) throw this->fail("sharedSecretENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridEcc::signHashENC(const std::string& encodedHash, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privkey, const std::shared_ptr<HybridPrngSpec>& prng) {
+  this->beginCall();
+  return signHashENC_impl(encodedHash, encoding, privkey, prng);
+}
+std::string HybridEcc::signHashENC_impl(const std::string& encodedHash, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privkey, const std::shared_ptr<HybridPrngSpec>& prng) {
+  rt::checkNoNul(encodedHash, "encodedHash");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().SignHashENC(encodedHash.c_str(), encoding.c_str(), rt::implOf<HybridPrivateKey>(privkey, "privkey").ck(), rt::implOf<HybridPrng>(prng, "prng").ck(), _out)) throw this->fail("signHashENC");
+  return rt::stdString(_out);
+}
+
+double HybridEcc::verifyHashENC(const std::string& encodedHash, const std::string& encodedSig, const std::string& encoding, const std::shared_ptr<HybridPublicKeySpec>& pubkey) {
+  this->beginCall();
+  return verifyHashENC_impl(encodedHash, encodedSig, encoding, pubkey);
+}
+double HybridEcc::verifyHashENC_impl(const std::string& encodedHash, const std::string& encodedSig, const std::string& encoding, const std::shared_ptr<HybridPublicKeySpec>& pubkey) {
+  rt::checkNoNul(encodedHash, "encodedHash");
+  rt::checkNoNul(encodedSig, "encodedSig");
+  rt::checkNoNul(encoding, "encoding");
+  return static_cast<double>(this->ck().VerifyHashENC(encodedHash.c_str(), encodedSig.c_str(), encoding.c_str(), rt::implOf<HybridPublicKey>(pubkey, "pubkey").ck()));
+}
+
+std::string HybridEcc::signBd(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlg, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridPrngSpec>& prng) {
+  this->beginCall();
+  return signBd_impl(bdData, hashAlg, encoding, privKey, prng);
+}
+std::string HybridEcc::signBd_impl(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlg, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridPrngSpec>& prng) {
+  rt::checkNoNul(hashAlg, "hashAlg");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().SignBd(rt::implOf<HybridBinData>(bdData, "bdData").ck(), hashAlg.c_str(), encoding.c_str(), rt::implOf<HybridPrivateKey>(privKey, "privKey").ck(), rt::implOf<HybridPrng>(prng, "prng").ck(), _out)) throw this->fail("signBd");
+  return rt::stdString(_out);
+}
+
+double HybridEcc::verifyBd(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlg, const std::string& encodedSig, const std::string& encoding, const std::shared_ptr<HybridPublicKeySpec>& pubkey) {
+  this->beginCall();
+  return verifyBd_impl(bdData, hashAlg, encodedSig, encoding, pubkey);
+}
+double HybridEcc::verifyBd_impl(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlg, const std::string& encodedSig, const std::string& encoding, const std::shared_ptr<HybridPublicKeySpec>& pubkey) {
+  rt::checkNoNul(hashAlg, "hashAlg");
+  rt::checkNoNul(encodedSig, "encodedSig");
+  rt::checkNoNul(encoding, "encoding");
+  return static_cast<double>(this->ck().VerifyBd(rt::implOf<HybridBinData>(bdData, "bdData").ck(), hashAlg.c_str(), encodedSig.c_str(), encoding.c_str(), rt::implOf<HybridPublicKey>(pubkey, "pubkey").ck()));
+}
+
+std::string HybridEcc::signBdUsingCert(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlg, const std::string& encoding, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  return signBdUsingCert_impl(bdData, hashAlg, encoding, cert);
+}
+std::string HybridEcc::signBdUsingCert_impl(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlg, const std::string& encoding, const std::shared_ptr<HybridCertSpec>& cert) {
+  rt::checkNoNul(hashAlg, "hashAlg");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().SignBdUsingCert(rt::implOf<HybridBinData>(bdData, "bdData").ck(), hashAlg.c_str(), encoding.c_str(), rt::implOf<HybridCert>(cert, "cert").ck(), _out)) throw this->fail("signBdUsingCert");
+  return rt::stdString(_out);
+}
+
+std::string HybridEcc::signHashUsingCert(const std::string& encodedHash, const std::string& encoding, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  return signHashUsingCert_impl(encodedHash, encoding, cert);
+}
+std::string HybridEcc::signHashUsingCert_impl(const std::string& encodedHash, const std::string& encoding, const std::shared_ptr<HybridCertSpec>& cert) {
+  rt::checkNoNul(encodedHash, "encodedHash");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().SignHashUsingCert(encodedHash.c_str(), encoding.c_str(), rt::implOf<HybridCert>(cert, "cert").ck(), _out)) throw this->fail("signHashUsingCert");
+  return rt::stdString(_out);
+}
+
+void HybridEcc::genKey(const std::string& curveName, const std::shared_ptr<HybridPrngSpec>& prng, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  genKey_impl(curveName, prng, privKey);
+}
+void HybridEcc::genKey_impl(const std::string& curveName, const std::shared_ptr<HybridPrngSpec>& prng, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  rt::checkNoNul(curveName, "curveName");
+  if (!this->ck().GenKey(curveName.c_str(), rt::implOf<HybridPrng>(prng, "prng").ck(), rt::implOf<HybridPrivateKey>(privKey, "privKey").ck())) throw this->fail("genKey");
+}
+
+void HybridEcc::genKey2(const std::string& curveName, const std::string& encodedK, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  genKey2_impl(curveName, encodedK, encoding, privKey);
+}
+void HybridEcc::genKey2_impl(const std::string& curveName, const std::string& encodedK, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  rt::checkNoNul(curveName, "curveName");
+  rt::checkNoNul(encodedK, "encodedK");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().GenKey2(curveName.c_str(), encodedK.c_str(), encoding.c_str(), rt::implOf<HybridPrivateKey>(privKey, "privKey").ck())) throw this->fail("genKey2");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridEcc.hpp

@@ -0,0 +1,55 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Ecc: the Nitro HybridObject over Chilkat's CkEcc (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridEccSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkEcc.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridEcc final : public HybridEccSpec, public ChilkatObject<CkEcc> {
+public:
+  HybridEcc();                                  // `new Ecc()` from JS
+  explicit HybridEcc(CkEcc* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  bool getAsnFormat() override;
+  void setAsnFormat(bool value) override;
+
+  // ---- Methods ----
+  std::string sharedSecretENC(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridPublicKeySpec>& pubKey, const std::string& encoding) override;
+  std::string signHashENC(const std::string& encodedHash, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privkey, const std::shared_ptr<HybridPrngSpec>& prng) override;
+  double verifyHashENC(const std::string& encodedHash, const std::string& encodedSig, const std::string& encoding, const std::shared_ptr<HybridPublicKeySpec>& pubkey) override;
+  std::string signBd(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlg, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridPrngSpec>& prng) override;
+  double verifyBd(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlg, const std::string& encodedSig, const std::string& encoding, const std::shared_ptr<HybridPublicKeySpec>& pubkey) override;
+  std::string signBdUsingCert(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlg, const std::string& encoding, const std::shared_ptr<HybridCertSpec>& cert) override;
+  std::string signHashUsingCert(const std::string& encodedHash, const std::string& encoding, const std::shared_ptr<HybridCertSpec>& cert) override;
+  void genKey(const std::string& curveName, const std::shared_ptr<HybridPrngSpec>& prng, const std::shared_ptr<HybridPrivateKeySpec>& privKey) override;
+  void genKey2(const std::string& curveName, const std::string& encodedK, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privKey) override;
+
+private:
+  void init();
+  std::string sharedSecretENC_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridPublicKeySpec>& pubKey, const std::string& encoding);
+  std::string signHashENC_impl(const std::string& encodedHash, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privkey, const std::shared_ptr<HybridPrngSpec>& prng);
+  double verifyHashENC_impl(const std::string& encodedHash, const std::string& encodedSig, const std::string& encoding, const std::shared_ptr<HybridPublicKeySpec>& pubkey);
+  std::string signBd_impl(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlg, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privKey, const std::shared_ptr<HybridPrngSpec>& prng);
+  double verifyBd_impl(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlg, const std::string& encodedSig, const std::string& encoding, const std::shared_ptr<HybridPublicKeySpec>& pubkey);
+  std::string signBdUsingCert_impl(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlg, const std::string& encoding, const std::shared_ptr<HybridCertSpec>& cert);
+  std::string signHashUsingCert_impl(const std::string& encodedHash, const std::string& encoding, const std::shared_ptr<HybridCertSpec>& cert);
+  void genKey_impl(const std::string& curveName, const std::shared_ptr<HybridPrngSpec>& prng, const std::shared_ptr<HybridPrivateKeySpec>& privKey);
+  void genKey2_impl(const std::string& curveName, const std::string& encodedK, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privKey);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridEdDSA.cpp

@@ -0,0 +1,147 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridEdDSA.hpp"
+#include "HybridBinData.hpp"
+#include "HybridPrivateKey.hpp"
+#include "HybridPrng.hpp"
+#include "HybridPublicKey.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridEdDSA::HybridEdDSA()
+    : HybridObject(HybridEdDSASpec::TAG), ChilkatObject<CkEdDSA>("EdDSA", CkEdDSA::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridEdDSA::HybridEdDSA(CkEdDSA* owned)
+    : HybridObject(HybridEdDSASpec::TAG), ChilkatObject<CkEdDSA>("EdDSA", owned) {
+  init();
+}
+
+void HybridEdDSA::init() {
+}
+
+void HybridEdDSA::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridEdDSA::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEdDSA::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEdDSA::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEdDSA::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridEdDSA::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridEdDSA::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridEdDSA::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridEdDSA::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridEdDSA::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridEdDSA::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridEdDSA::getAlgorithm() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Algorithm(_s);
+  return rt::stdString(_s);
+}
+void HybridEdDSA::setAlgorithm(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "algorithm");
+  this->ck().put_Algorithm(value.c_str());
+}
+std::string HybridEdDSA::getContext() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Context(_s);
+  return rt::stdString(_s);
+}
+void HybridEdDSA::setContext(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "context");
+  this->ck().put_Context(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridEdDSA::genEd25519Key(const std::shared_ptr<HybridPrngSpec>& prng, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  genEd25519Key_impl(prng, privKey);
+}
+void HybridEdDSA::genEd25519Key_impl(const std::shared_ptr<HybridPrngSpec>& prng, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  if (!this->ck().GenEd25519Key(rt::implOf<HybridPrng>(prng, "prng").ck(), rt::implOf<HybridPrivateKey>(privKey, "privKey").ck())) throw this->fail("genEd25519Key");
+}
+
+std::string HybridEdDSA::signBdENC(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privkey) {
+  this->beginCall();
+  return signBdENC_impl(bd, encoding, privkey);
+}
+std::string HybridEdDSA::signBdENC_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privkey) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().SignBdENC(rt::implOf<HybridBinData>(bd, "bd").ck(), encoding.c_str(), rt::implOf<HybridPrivateKey>(privkey, "privkey").ck(), _out)) throw this->fail("signBdENC");
+  return rt::stdString(_out);
+}
+
+void HybridEdDSA::verifyBdENC(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& encodedSig, const std::string& enocding, const std::shared_ptr<HybridPublicKeySpec>& pubkey) {
+  this->beginCall();
+  verifyBdENC_impl(bd, encodedSig, enocding, pubkey);
+}
+void HybridEdDSA::verifyBdENC_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& encodedSig, const std::string& enocding, const std::shared_ptr<HybridPublicKeySpec>& pubkey) {
+  rt::checkNoNul(encodedSig, "encodedSig");
+  rt::checkNoNul(enocding, "enocding");
+  if (!this->ck().VerifyBdENC(rt::implOf<HybridBinData>(bd, "bd").ck(), encodedSig.c_str(), enocding.c_str(), rt::implOf<HybridPublicKey>(pubkey, "pubkey").ck())) throw this->fail("verifyBdENC");
+}
+
+std::string HybridEdDSA::sharedSecretENC(const std::shared_ptr<HybridPrivateKeySpec>& privkey, const std::shared_ptr<HybridPublicKeySpec>& pubkey, const std::string& encoding) {
+  this->beginCall();
+  return sharedSecretENC_impl(privkey, pubkey, encoding);
+}
+std::string HybridEdDSA::sharedSecretENC_impl(const std::shared_ptr<HybridPrivateKeySpec>& privkey, const std::shared_ptr<HybridPublicKeySpec>& pubkey, const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().SharedSecretENC(rt::implOf<HybridPrivateKey>(privkey, "privkey").ck(), rt::implOf<HybridPublicKey>(pubkey, "pubkey").ck(), encoding.c_str(), _out)) throw this->fail("sharedSecretENC");
+  return rt::stdString(_out);
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridEdDSA.hpp

@@ -0,0 +1,47 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// EdDSA: the Nitro HybridObject over Chilkat's CkEdDSA (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridEdDSASpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkEdDSA.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridEdDSA final : public HybridEdDSASpec, public ChilkatObject<CkEdDSA> {
+public:
+  HybridEdDSA();                                  // `new EdDSA()` from JS
+  explicit HybridEdDSA(CkEdDSA* 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 getAlgorithm() override;
+  void setAlgorithm(const std::string& value) override;
+  std::string getContext() override;
+  void setContext(const std::string& value) override;
+
+  // ---- Methods ----
+  void genEd25519Key(const std::shared_ptr<HybridPrngSpec>& prng, const std::shared_ptr<HybridPrivateKeySpec>& privKey) override;
+  std::string signBdENC(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privkey) override;
+  void verifyBdENC(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& encodedSig, const std::string& enocding, const std::shared_ptr<HybridPublicKeySpec>& pubkey) override;
+  std::string sharedSecretENC(const std::shared_ptr<HybridPrivateKeySpec>& privkey, const std::shared_ptr<HybridPublicKeySpec>& pubkey, const std::string& encoding) override;
+
+private:
+  void init();
+  void genEd25519Key_impl(const std::shared_ptr<HybridPrngSpec>& prng, const std::shared_ptr<HybridPrivateKeySpec>& privKey);
+  std::string signBdENC_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& encoding, const std::shared_ptr<HybridPrivateKeySpec>& privkey);
+  void verifyBdENC_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& encodedSig, const std::string& enocding, const std::shared_ptr<HybridPublicKeySpec>& pubkey);
+  std::string sharedSecretENC_impl(const std::shared_ptr<HybridPrivateKeySpec>& privkey, const std::shared_ptr<HybridPublicKeySpec>& pubkey, const std::string& encoding);
+};
+
+} // namespace margelo::nitro::chilkat