@chilkat/react-native 11.6.1

package/cpp/HybridJws.cpp

@@ -0,0 +1,290 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridJws.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCert.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 {
+
+HybridJws::HybridJws()
+    : HybridObject(HybridJwsSpec::TAG), ChilkatObject<CkJws>("Jws", CkJws::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridJws::HybridJws(CkJws* owned)
+    : HybridObject(HybridJwsSpec::TAG), ChilkatObject<CkJws>("Jws", owned) {
+  init();
+}
+
+void HybridJws::init() {
+}
+
+void HybridJws::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridJws::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJws::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJws::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJws::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJws::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridJws::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridJws::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridJws::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridJws::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridJws::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridJws::getNumSignatures() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumSignatures());
+}
+bool HybridJws::getPreferCompact() {
+  this->beginCall();
+  return this->ck().get_PreferCompact();
+}
+void HybridJws::setPreferCompact(bool value) {
+  this->beginCall();
+  this->ck().put_PreferCompact(value);
+}
+bool HybridJws::getPreferFlattened() {
+  this->beginCall();
+  return this->ck().get_PreferFlattened();
+}
+void HybridJws::setPreferFlattened(bool value) {
+  this->beginCall();
+  this->ck().put_PreferFlattened(value);
+}
+std::string HybridJws::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridJws::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridJws::setProtectedHeader(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  setProtectedHeader_impl(index, json);
+}
+void HybridJws::setProtectedHeader_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().SetProtectedHeader(rt::toInt(index, "index"), rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("setProtectedHeader");
+}
+
+void HybridJws::setUnprotectedHeader(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  setUnprotectedHeader_impl(index, json);
+}
+void HybridJws::setUnprotectedHeader_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().SetUnprotectedHeader(rt::toInt(index, "index"), rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("setUnprotectedHeader");
+}
+
+std::string HybridJws::createJws() {
+  this->beginCall();
+  return createJws_impl();
+}
+std::string HybridJws::createJws_impl() {
+  CkString _out;
+  if (!this->ck().CreateJws(_out)) throw this->fail("createJws");
+  return rt::stdString(_out);
+}
+
+void HybridJws::createJwsSb(const std::shared_ptr<HybridStringBuilderSpec>& sbJws) {
+  this->beginCall();
+  createJwsSb_impl(sbJws);
+}
+void HybridJws::createJwsSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbJws) {
+  if (!this->ck().CreateJwsSb(rt::implOf<HybridStringBuilder>(sbJws, "sbJws").ck())) throw this->fail("createJwsSb");
+}
+
+void HybridJws::setPayloadSb(const std::shared_ptr<HybridStringBuilderSpec>& sbPayload, const std::string& charset, bool includeBom) {
+  this->beginCall();
+  setPayloadSb_impl(sbPayload, charset, includeBom);
+}
+void HybridJws::setPayloadSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbPayload, const std::string& charset, bool includeBom) {
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().SetPayloadSb(rt::implOf<HybridStringBuilder>(sbPayload, "sbPayload").ck(), charset.c_str(), includeBom)) throw this->fail("setPayloadSb");
+}
+
+void HybridJws::setPayloadBd(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  setPayloadBd_impl(binData);
+}
+void HybridJws::setPayloadBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().SetPayloadBd(rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("setPayloadBd");
+}
+
+void HybridJws::getPayloadSb(const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sbPayload) {
+  this->beginCall();
+  getPayloadSb_impl(charset, sbPayload);
+}
+void HybridJws::getPayloadSb_impl(const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sbPayload) {
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().GetPayloadSb(charset.c_str(), rt::implOf<HybridStringBuilder>(sbPayload, "sbPayload").ck())) throw this->fail("getPayloadSb");
+}
+
+void HybridJws::getPayloadBd(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  getPayloadBd_impl(binData);
+}
+void HybridJws::getPayloadBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData) {
+  if (!this->ck().GetPayloadBd(rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("getPayloadBd");
+}
+
+void HybridJws::loadJwsSb(const std::shared_ptr<HybridStringBuilderSpec>& sbJws) {
+  this->beginCall();
+  loadJwsSb_impl(sbJws);
+}
+void HybridJws::loadJwsSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbJws) {
+  if (!this->ck().LoadJwsSb(rt::implOf<HybridStringBuilder>(sbJws, "sbJws").ck())) throw this->fail("loadJwsSb");
+}
+
+void HybridJws::loadJws(const std::string& jwsStr) {
+  this->beginCall();
+  loadJws_impl(jwsStr);
+}
+void HybridJws::loadJws_impl(const std::string& jwsStr) {
+  rt::checkNoNul(jwsStr, "jwsStr");
+  if (!this->ck().LoadJws(jwsStr.c_str())) throw this->fail("loadJws");
+}
+
+void HybridJws::setMacKey(double index, const std::string& key, const std::string& encoding) {
+  this->beginCall();
+  setMacKey_impl(index, key, encoding);
+}
+void HybridJws::setMacKey_impl(double index, const std::string& key, const std::string& encoding) {
+  rt::checkNoNul(key, "key");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().SetMacKey(rt::toInt(index, "index"), key.c_str(), encoding.c_str())) throw this->fail("setMacKey");
+}
+
+void HybridJws::setMacKeyBd(double index, const std::shared_ptr<HybridBinDataSpec>& key) {
+  this->beginCall();
+  setMacKeyBd_impl(index, key);
+}
+void HybridJws::setMacKeyBd_impl(double index, const std::shared_ptr<HybridBinDataSpec>& key) {
+  if (!this->ck().SetMacKeyBd(rt::toInt(index, "index"), rt::implOf<HybridBinData>(key, "key").ck())) throw this->fail("setMacKeyBd");
+}
+
+void HybridJws::setPrivateKey(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  setPrivateKey_impl(index, privKey);
+}
+void HybridJws::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 HybridJws::setPublicKey(double index, const std::shared_ptr<HybridPublicKeySpec>& pubKey) {
+  this->beginCall();
+  setPublicKey_impl(index, pubKey);
+}
+void HybridJws::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");
+}
+
+double HybridJws::validate(double index) {
+  this->beginCall();
+  return validate_impl(index);
+}
+double HybridJws::validate_impl(double index) {
+  return static_cast<double>(this->ck().Validate(rt::toInt(index, "index")));
+}
+
+void HybridJws::setPayload(const std::string& payload, const std::string& charset, bool includeBom) {
+  this->beginCall();
+  setPayload_impl(payload, charset, includeBom);
+}
+void HybridJws::setPayload_impl(const std::string& payload, const std::string& charset, bool includeBom) {
+  rt::checkNoNul(payload, "payload");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().SetPayload(payload.c_str(), charset.c_str(), includeBom)) throw this->fail("setPayload");
+}
+
+std::string HybridJws::getPayload(const std::string& charset) {
+  this->beginCall();
+  return getPayload_impl(charset);
+}
+std::string HybridJws::getPayload_impl(const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  CkString _out;
+  if (!this->ck().GetPayload(charset.c_str(), _out)) throw this->fail("getPayload");
+  return rt::stdString(_out);
+}
+
+void HybridJws::getProtectedH(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getProtectedH_impl(index, json);
+}
+void HybridJws::getProtectedH_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().GetProtectedH(rt::toInt(index, "index"), rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("getProtectedH");
+}
+
+void HybridJws::getUnprotectedH(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getUnprotectedH_impl(index, json);
+}
+void HybridJws::getUnprotectedH_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().GetUnprotectedH(rt::toInt(index, "index"), rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("getUnprotectedH");
+}
+
+void HybridJws::setSigningCert(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  setSigningCert_impl(index, cert);
+}
+void HybridJws::setSigningCert_impl(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().SetSigningCert(rt::toInt(index, "index"), rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("setSigningCert");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridJws.hpp

@@ -0,0 +1,82 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Jws: the Nitro HybridObject over Chilkat's CkJws (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridJwsSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkJws.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridJws final : public HybridJwsSpec, public ChilkatObject<CkJws> {
+public:
+  HybridJws();                                  // `new Jws()` from JS
+  explicit HybridJws(CkJws* 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 getNumSignatures() 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(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void setUnprotectedHeader(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  std::string createJws() override;
+  void createJwsSb(const std::shared_ptr<HybridStringBuilderSpec>& sbJws) override;
+  void setPayloadSb(const std::shared_ptr<HybridStringBuilderSpec>& sbPayload, const std::string& charset, bool includeBom) override;
+  void setPayloadBd(const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  void getPayloadSb(const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sbPayload) override;
+  void getPayloadBd(const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  void loadJwsSb(const std::shared_ptr<HybridStringBuilderSpec>& sbJws) override;
+  void loadJws(const std::string& jwsStr) override;
+  void setMacKey(double index, const std::string& key, const std::string& encoding) override;
+  void setMacKeyBd(double index, const std::shared_ptr<HybridBinDataSpec>& key) override;
+  void setPrivateKey(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey) override;
+  void setPublicKey(double index, const std::shared_ptr<HybridPublicKeySpec>& pubKey) override;
+  double validate(double index) override;
+  void setPayload(const std::string& payload, const std::string& charset, bool includeBom) override;
+  std::string getPayload(const std::string& charset) override;
+  void getProtectedH(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void getUnprotectedH(double index, const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void setSigningCert(double index, const std::shared_ptr<HybridCertSpec>& cert) override;
+
+private:
+  void init();
+  void setProtectedHeader_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void setUnprotectedHeader_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& json);
+  std::string createJws_impl();
+  void createJwsSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbJws);
+  void setPayloadSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbPayload, const std::string& charset, bool includeBom);
+  void setPayloadBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData);
+  void getPayloadSb_impl(const std::string& charset, const std::shared_ptr<HybridStringBuilderSpec>& sbPayload);
+  void getPayloadBd_impl(const std::shared_ptr<HybridBinDataSpec>& binData);
+  void loadJwsSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sbJws);
+  void loadJws_impl(const std::string& jwsStr);
+  void setMacKey_impl(double index, const std::string& key, const std::string& encoding);
+  void setMacKeyBd_impl(double index, const std::shared_ptr<HybridBinDataSpec>& key);
+  void setPrivateKey_impl(double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey);
+  void setPublicKey_impl(double index, const std::shared_ptr<HybridPublicKeySpec>& pubKey);
+  double validate_impl(double index);
+  void setPayload_impl(const std::string& payload, const std::string& charset, bool includeBom);
+  std::string getPayload_impl(const std::string& charset);
+  void getProtectedH_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void getUnprotectedH_impl(double index, const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void setSigningCert_impl(double index, const std::shared_ptr<HybridCertSpec>& cert);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridJwt.cpp

@@ -0,0 +1,198 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridJwt.hpp"
+#include "HybridCert.hpp"
+#include "HybridPrivateKey.hpp"
+#include "HybridPublicKey.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridJwt::HybridJwt()
+    : HybridObject(HybridJwtSpec::TAG), ChilkatObject<CkJwt>("Jwt", CkJwt::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridJwt::HybridJwt(CkJwt* owned)
+    : HybridObject(HybridJwtSpec::TAG), ChilkatObject<CkJwt>("Jwt", owned) {
+  init();
+}
+
+void HybridJwt::init() {
+}
+
+void HybridJwt::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridJwt::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJwt::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJwt::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJwt::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJwt::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridJwt::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridJwt::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridJwt::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridJwt::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridJwt::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridJwt::getAutoCompact() {
+  this->beginCall();
+  return this->ck().get_AutoCompact();
+}
+void HybridJwt::setAutoCompact(bool value) {
+  this->beginCall();
+  this->ck().put_AutoCompact(value);
+}
+std::string HybridJwt::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridJwt::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+std::string HybridJwt::createJwt(const std::string& header, const std::string& payload, const std::string& password) {
+  this->beginCall();
+  return createJwt_impl(header, payload, password);
+}
+std::string HybridJwt::createJwt_impl(const std::string& header, const std::string& payload, const std::string& password) {
+  rt::checkNoNul(header, "header");
+  rt::checkNoNul(payload, "payload");
+  rt::checkNoNul(password, "password");
+  CkString _out;
+  if (!this->ck().CreateJwt(header.c_str(), payload.c_str(), password.c_str(), _out)) throw this->fail("createJwt");
+  return rt::stdString(_out);
+}
+
+std::string HybridJwt::createJwtPk(const std::string& header, const std::string& payload, const std::shared_ptr<HybridPrivateKeySpec>& key) {
+  this->beginCall();
+  return createJwtPk_impl(header, payload, key);
+}
+std::string HybridJwt::createJwtPk_impl(const std::string& header, const std::string& payload, const std::shared_ptr<HybridPrivateKeySpec>& key) {
+  rt::checkNoNul(header, "header");
+  rt::checkNoNul(payload, "payload");
+  CkString _out;
+  if (!this->ck().CreateJwtPk(header.c_str(), payload.c_str(), rt::implOf<HybridPrivateKey>(key, "key").ck(), _out)) throw this->fail("createJwtPk");
+  return rt::stdString(_out);
+}
+
+double HybridJwt::genNumericDate(double numSecOffset) {
+  this->beginCall();
+  return genNumericDate_impl(numSecOffset);
+}
+double HybridJwt::genNumericDate_impl(double numSecOffset) {
+  return static_cast<double>(this->ck().GenNumericDate(rt::toInt(numSecOffset, "numSecOffset")));
+}
+
+std::string HybridJwt::getHeader(const std::string& token) {
+  this->beginCall();
+  return getHeader_impl(token);
+}
+std::string HybridJwt::getHeader_impl(const std::string& token) {
+  rt::checkNoNul(token, "token");
+  CkString _out;
+  if (!this->ck().GetHeader(token.c_str(), _out)) throw this->fail("getHeader");
+  return rt::stdString(_out);
+}
+
+std::string HybridJwt::getPayload(const std::string& token) {
+  this->beginCall();
+  return getPayload_impl(token);
+}
+std::string HybridJwt::getPayload_impl(const std::string& token) {
+  rt::checkNoNul(token, "token");
+  CkString _out;
+  if (!this->ck().GetPayload(token.c_str(), _out)) throw this->fail("getPayload");
+  return rt::stdString(_out);
+}
+
+bool HybridJwt::isTimeValid(const std::string& jwt, double leeway) {
+  this->beginCall();
+  return isTimeValid_impl(jwt, leeway);
+}
+bool HybridJwt::isTimeValid_impl(const std::string& jwt, double leeway) {
+  rt::checkNoNul(jwt, "jwt");
+  return this->ck().IsTimeValid(jwt.c_str(), rt::toInt(leeway, "leeway"));
+}
+
+void HybridJwt::verifyJwt(const std::string& token, const std::string& password) {
+  this->beginCall();
+  verifyJwt_impl(token, password);
+}
+void HybridJwt::verifyJwt_impl(const std::string& token, const std::string& password) {
+  rt::checkNoNul(token, "token");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().VerifyJwt(token.c_str(), password.c_str())) throw this->fail("verifyJwt");
+}
+
+void HybridJwt::verifyJwtPk(const std::string& token, const std::shared_ptr<HybridPublicKeySpec>& key) {
+  this->beginCall();
+  verifyJwtPk_impl(token, key);
+}
+void HybridJwt::verifyJwtPk_impl(const std::string& token, const std::shared_ptr<HybridPublicKeySpec>& key) {
+  rt::checkNoNul(token, "token");
+  if (!this->ck().VerifyJwtPk(token.c_str(), rt::implOf<HybridPublicKey>(key, "key").ck())) throw this->fail("verifyJwtPk");
+}
+
+std::string HybridJwt::createJwtCert(const std::string& header, const std::string& payload, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  return createJwtCert_impl(header, payload, cert);
+}
+std::string HybridJwt::createJwtCert_impl(const std::string& header, const std::string& payload, const std::shared_ptr<HybridCertSpec>& cert) {
+  rt::checkNoNul(header, "header");
+  rt::checkNoNul(payload, "payload");
+  CkString _out;
+  if (!this->ck().CreateJwtCert(header.c_str(), payload.c_str(), rt::implOf<HybridCert>(cert, "cert").ck(), _out)) throw this->fail("createJwtCert");
+  return rt::stdString(_out);
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridJwt.hpp

@@ -0,0 +1,57 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Jwt: the Nitro HybridObject over Chilkat's CkJwt (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridJwtSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkJwt.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridJwt final : public HybridJwtSpec, public ChilkatObject<CkJwt> {
+public:
+  HybridJwt();                                  // `new Jwt()` from JS
+  explicit HybridJwt(CkJwt* 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 getAutoCompact() override;
+  void setAutoCompact(bool value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+
+  // ---- Methods ----
+  std::string createJwt(const std::string& header, const std::string& payload, const std::string& password) override;
+  std::string createJwtPk(const std::string& header, const std::string& payload, const std::shared_ptr<HybridPrivateKeySpec>& key) override;
+  double genNumericDate(double numSecOffset) override;
+  std::string getHeader(const std::string& token) override;
+  std::string getPayload(const std::string& token) override;
+  bool isTimeValid(const std::string& jwt, double leeway) override;
+  void verifyJwt(const std::string& token, const std::string& password) override;
+  void verifyJwtPk(const std::string& token, const std::shared_ptr<HybridPublicKeySpec>& key) override;
+  std::string createJwtCert(const std::string& header, const std::string& payload, const std::shared_ptr<HybridCertSpec>& cert) override;
+
+private:
+  void init();
+  std::string createJwt_impl(const std::string& header, const std::string& payload, const std::string& password);
+  std::string createJwtPk_impl(const std::string& header, const std::string& payload, const std::shared_ptr<HybridPrivateKeySpec>& key);
+  double genNumericDate_impl(double numSecOffset);
+  std::string getHeader_impl(const std::string& token);
+  std::string getPayload_impl(const std::string& token);
+  bool isTimeValid_impl(const std::string& jwt, double leeway);
+  void verifyJwt_impl(const std::string& token, const std::string& password);
+  void verifyJwtPk_impl(const std::string& token, const std::shared_ptr<HybridPublicKeySpec>& key);
+  std::string createJwtCert_impl(const std::string& header, const std::string& payload, const std::shared_ptr<HybridCertSpec>& cert);
+};
+
+} // namespace margelo::nitro::chilkat