@chilkat/react-native 11.6.1

package/cpp/HybridJavaKeyStore.cpp

@@ -0,0 +1,387 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridJavaKeyStore.hpp"
+#include "HybridBinData.hpp"
+#include "HybridCert.hpp"
+#include "HybridCertChain.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridPem.hpp"
+#include "HybridPfx.hpp"
+#include "HybridPrivateKey.hpp"
+#include "HybridStringBuilder.hpp"
+#include "HybridXmlCertVault.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridJavaKeyStore::HybridJavaKeyStore()
+    : HybridObject(HybridJavaKeyStoreSpec::TAG), ChilkatObject<CkJavaKeyStore>("JavaKeyStore", CkJavaKeyStore::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridJavaKeyStore::HybridJavaKeyStore(CkJavaKeyStore* owned)
+    : HybridObject(HybridJavaKeyStoreSpec::TAG), ChilkatObject<CkJavaKeyStore>("JavaKeyStore", owned) {
+  init();
+}
+
+void HybridJavaKeyStore::init() {
+}
+
+void HybridJavaKeyStore::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridJavaKeyStore::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJavaKeyStore::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJavaKeyStore::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJavaKeyStore::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJavaKeyStore::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridJavaKeyStore::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridJavaKeyStore::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridJavaKeyStore::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridJavaKeyStore::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridJavaKeyStore::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridJavaKeyStore::getNumPrivateKeys() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumPrivateKeys());
+}
+double HybridJavaKeyStore::getNumTrustedCerts() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumTrustedCerts());
+}
+bool HybridJavaKeyStore::getRequireCompleteChain() {
+  this->beginCall();
+  return this->ck().get_RequireCompleteChain();
+}
+void HybridJavaKeyStore::setRequireCompleteChain(bool value) {
+  this->beginCall();
+  this->ck().put_RequireCompleteChain(value);
+}
+bool HybridJavaKeyStore::getVerifyKeyedDigest() {
+  this->beginCall();
+  return this->ck().get_VerifyKeyedDigest();
+}
+void HybridJavaKeyStore::setVerifyKeyedDigest(bool value) {
+  this->beginCall();
+  this->ck().put_VerifyKeyedDigest(value);
+}
+double HybridJavaKeyStore::getNumSecretKeys() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumSecretKeys());
+}
+
+// ---- Methods ----
+
+void HybridJavaKeyStore::addPfx(const std::shared_ptr<HybridPfxSpec>& pfx, const std::string& aliasName, const std::string& password) {
+  this->beginCall();
+  addPfx_impl(pfx, aliasName, password);
+}
+void HybridJavaKeyStore::addPfx_impl(const std::shared_ptr<HybridPfxSpec>& pfx, const std::string& aliasName, const std::string& password) {
+  rt::checkNoNul(aliasName, "aliasName");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().AddPfx(rt::implOf<HybridPfx>(pfx, "pfx").ck(), aliasName.c_str(), password.c_str())) throw this->fail("addPfx");
+}
+
+void HybridJavaKeyStore::addPrivateKey(const std::shared_ptr<HybridCertSpec>& cert, const std::string& aliasName, const std::string& password) {
+  this->beginCall();
+  addPrivateKey_impl(cert, aliasName, password);
+}
+void HybridJavaKeyStore::addPrivateKey_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::string& aliasName, const std::string& password) {
+  rt::checkNoNul(aliasName, "aliasName");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().AddPrivateKey(rt::implOf<HybridCert>(cert, "cert").ck(), aliasName.c_str(), password.c_str())) throw this->fail("addPrivateKey");
+}
+
+void HybridJavaKeyStore::addTrustedCert(const std::shared_ptr<HybridCertSpec>& cert, const std::string& aliasName) {
+  this->beginCall();
+  addTrustedCert_impl(cert, aliasName);
+}
+void HybridJavaKeyStore::addTrustedCert_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::string& aliasName) {
+  rt::checkNoNul(aliasName, "aliasName");
+  if (!this->ck().AddTrustedCert(rt::implOf<HybridCert>(cert, "cert").ck(), aliasName.c_str())) throw this->fail("addTrustedCert");
+}
+
+void HybridJavaKeyStore::changePassword(double index, const std::string& oldPassword, const std::string& newPassword) {
+  this->beginCall();
+  changePassword_impl(index, oldPassword, newPassword);
+}
+void HybridJavaKeyStore::changePassword_impl(double index, const std::string& oldPassword, const std::string& newPassword) {
+  rt::checkNoNul(oldPassword, "oldPassword");
+  rt::checkNoNul(newPassword, "newPassword");
+  if (!this->ck().ChangePassword(rt::toInt(index, "index"), oldPassword.c_str(), newPassword.c_str())) throw this->fail("changePassword");
+}
+
+std::string HybridJavaKeyStore::getPrivateKeyAlias(double index) {
+  this->beginCall();
+  return getPrivateKeyAlias_impl(index);
+}
+std::string HybridJavaKeyStore::getPrivateKeyAlias_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetPrivateKeyAlias(rt::toInt(index, "index"), _out)) throw this->fail("getPrivateKeyAlias");
+  return rt::stdString(_out);
+}
+
+std::string HybridJavaKeyStore::getTrustedCertAlias(double index) {
+  this->beginCall();
+  return getTrustedCertAlias_impl(index);
+}
+std::string HybridJavaKeyStore::getTrustedCertAlias_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetTrustedCertAlias(rt::toInt(index, "index"), _out)) throw this->fail("getTrustedCertAlias");
+  return rt::stdString(_out);
+}
+
+void HybridJavaKeyStore::loadEncoded(const std::string& password, const std::string& jksEncData, const std::string& encoding) {
+  this->beginCall();
+  loadEncoded_impl(password, jksEncData, encoding);
+}
+void HybridJavaKeyStore::loadEncoded_impl(const std::string& password, const std::string& jksEncData, const std::string& encoding) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(jksEncData, "jksEncData");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().LoadEncoded(password.c_str(), jksEncData.c_str(), encoding.c_str())) throw this->fail("loadEncoded");
+}
+
+void HybridJavaKeyStore::loadFile(const std::string& password, const std::string& path) {
+  this->beginCall();
+  loadFile_impl(password, path);
+}
+void HybridJavaKeyStore::loadFile_impl(const std::string& password, const std::string& path) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(path, "path");
+  if (!this->ck().LoadFile(password.c_str(), path.c_str())) throw this->fail("loadFile");
+}
+
+void HybridJavaKeyStore::removeEntry(double entryType, double index) {
+  this->beginCall();
+  removeEntry_impl(entryType, index);
+}
+void HybridJavaKeyStore::removeEntry_impl(double entryType, double index) {
+  if (!this->ck().RemoveEntry(rt::toInt(entryType, "entryType"), rt::toInt(index, "index"))) throw this->fail("removeEntry");
+}
+
+void HybridJavaKeyStore::setAlias(double entryType, double index, const std::string& aliasName) {
+  this->beginCall();
+  setAlias_impl(entryType, index, aliasName);
+}
+void HybridJavaKeyStore::setAlias_impl(double entryType, double index, const std::string& aliasName) {
+  rt::checkNoNul(aliasName, "aliasName");
+  if (!this->ck().SetAlias(rt::toInt(entryType, "entryType"), rt::toInt(index, "index"), aliasName.c_str())) throw this->fail("setAlias");
+}
+
+std::string HybridJavaKeyStore::toEncodedString(const std::string& password, const std::string& encoding) {
+  this->beginCall();
+  return toEncodedString_impl(password, encoding);
+}
+std::string HybridJavaKeyStore::toEncodedString_impl(const std::string& password, const std::string& encoding) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().ToEncodedString(password.c_str(), encoding.c_str(), _out)) throw this->fail("toEncodedString");
+  return rt::stdString(_out);
+}
+
+void HybridJavaKeyStore::toFile(const std::string& password, const std::string& path) {
+  this->beginCall();
+  toFile_impl(password, path);
+}
+void HybridJavaKeyStore::toFile_impl(const std::string& password, const std::string& path) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(path, "path");
+  if (!this->ck().ToFile(password.c_str(), path.c_str())) throw this->fail("toFile");
+}
+
+void HybridJavaKeyStore::useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  this->beginCall();
+  useCertVault_impl(vault);
+}
+void HybridJavaKeyStore::useCertVault_impl(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) {
+  if (!this->ck().UseCertVault(rt::implOf<HybridXmlCertVault>(vault, "vault").ck())) throw this->fail("useCertVault");
+}
+
+void HybridJavaKeyStore::toJwkSet(const std::string& password, const std::shared_ptr<HybridStringBuilderSpec>& sbJwkSet) {
+  this->beginCall();
+  toJwkSet_impl(password, sbJwkSet);
+}
+void HybridJavaKeyStore::toJwkSet_impl(const std::string& password, const std::shared_ptr<HybridStringBuilderSpec>& sbJwkSet) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().ToJwkSet(password.c_str(), rt::implOf<HybridStringBuilder>(sbJwkSet, "sbJwkSet").ck())) throw this->fail("toJwkSet");
+}
+
+std::string HybridJavaKeyStore::getSecretKeyAlias(double index) {
+  this->beginCall();
+  return getSecretKeyAlias_impl(index);
+}
+std::string HybridJavaKeyStore::getSecretKeyAlias_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetSecretKeyAlias(rt::toInt(index, "index"), _out)) throw this->fail("getSecretKeyAlias");
+  return rt::stdString(_out);
+}
+
+std::string HybridJavaKeyStore::getSecretKey(const std::string& password, double index, const std::string& encoding) {
+  this->beginCall();
+  return getSecretKey_impl(password, index, encoding);
+}
+std::string HybridJavaKeyStore::getSecretKey_impl(const std::string& password, double index, const std::string& encoding) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetSecretKey(password.c_str(), rt::toInt(index, "index"), encoding.c_str(), _out)) throw this->fail("getSecretKey");
+  return rt::stdString(_out);
+}
+
+void HybridJavaKeyStore::addSecretKey(const std::string& encodedKeyBytes, const std::string& encoding, const std::string& algorithm, const std::string& aliasName, const std::string& password) {
+  this->beginCall();
+  addSecretKey_impl(encodedKeyBytes, encoding, algorithm, aliasName, password);
+}
+void HybridJavaKeyStore::addSecretKey_impl(const std::string& encodedKeyBytes, const std::string& encoding, const std::string& algorithm, const std::string& aliasName, const std::string& password) {
+  rt::checkNoNul(encodedKeyBytes, "encodedKeyBytes");
+  rt::checkNoNul(encoding, "encoding");
+  rt::checkNoNul(algorithm, "algorithm");
+  rt::checkNoNul(aliasName, "aliasName");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().AddSecretKey(encodedKeyBytes.c_str(), encoding.c_str(), algorithm.c_str(), aliasName.c_str(), password.c_str())) throw this->fail("addSecretKey");
+}
+
+void HybridJavaKeyStore::loadJwkSet(const std::string& password, const std::shared_ptr<HybridJsonObjectSpec>& jwkSet) {
+  this->beginCall();
+  loadJwkSet_impl(password, jwkSet);
+}
+void HybridJavaKeyStore::loadJwkSet_impl(const std::string& password, const std::shared_ptr<HybridJsonObjectSpec>& jwkSet) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadJwkSet(password.c_str(), rt::implOf<HybridJsonObject>(jwkSet, "jwkSet").ck())) throw this->fail("loadJwkSet");
+}
+
+void HybridJavaKeyStore::loadBd(const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  loadBd_impl(password, bd);
+}
+void HybridJavaKeyStore::loadBd_impl(const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadBd(password.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("loadBd");
+}
+
+void HybridJavaKeyStore::trustedCertAt(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  trustedCertAt_impl(index, cert);
+}
+void HybridJavaKeyStore::trustedCertAt_impl(double index, const std::shared_ptr<HybridCertSpec>& cert) {
+  if (!this->ck().TrustedCertAt(rt::toInt(index, "index"), rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("trustedCertAt");
+}
+
+void HybridJavaKeyStore::privateKeyAt(const std::string& password, double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  privateKeyAt_impl(password, index, privKey);
+}
+void HybridJavaKeyStore::privateKeyAt_impl(const std::string& password, double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().PrivateKeyAt(password.c_str(), rt::toInt(index, "index"), rt::implOf<HybridPrivateKey>(privKey, "privKey").ck())) throw this->fail("privateKeyAt");
+}
+
+void HybridJavaKeyStore::certChainAt(double index, const std::shared_ptr<HybridCertChainSpec>& certChain) {
+  this->beginCall();
+  certChainAt_impl(index, certChain);
+}
+void HybridJavaKeyStore::certChainAt_impl(double index, const std::shared_ptr<HybridCertChainSpec>& certChain) {
+  if (!this->ck().CertChainAt(rt::toInt(index, "index"), rt::implOf<HybridCertChain>(certChain, "certChain").ck())) throw this->fail("certChainAt");
+}
+
+void HybridJavaKeyStore::certChainOf(const std::string& aliasName, bool caseSensitive, const std::shared_ptr<HybridCertChainSpec>& certChain) {
+  this->beginCall();
+  certChainOf_impl(aliasName, caseSensitive, certChain);
+}
+void HybridJavaKeyStore::certChainOf_impl(const std::string& aliasName, bool caseSensitive, const std::shared_ptr<HybridCertChainSpec>& certChain) {
+  rt::checkNoNul(aliasName, "aliasName");
+  if (!this->ck().CertChainOf(aliasName.c_str(), caseSensitive, rt::implOf<HybridCertChain>(certChain, "certChain").ck())) throw this->fail("certChainOf");
+}
+
+void HybridJavaKeyStore::privateKeyOf(const std::string& password, const std::string& aliasName, bool caseSensitive, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  privateKeyOf_impl(password, aliasName, caseSensitive, privKey);
+}
+void HybridJavaKeyStore::privateKeyOf_impl(const std::string& password, const std::string& aliasName, bool caseSensitive, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(aliasName, "aliasName");
+  if (!this->ck().PrivateKeyOf(password.c_str(), aliasName.c_str(), caseSensitive, rt::implOf<HybridPrivateKey>(privKey, "privKey").ck())) throw this->fail("privateKeyOf");
+}
+
+void HybridJavaKeyStore::trustedCertOf(const std::string& aliasName, bool caseSensitive, const std::shared_ptr<HybridCertSpec>& cert) {
+  this->beginCall();
+  trustedCertOf_impl(aliasName, caseSensitive, cert);
+}
+void HybridJavaKeyStore::trustedCertOf_impl(const std::string& aliasName, bool caseSensitive, const std::shared_ptr<HybridCertSpec>& cert) {
+  rt::checkNoNul(aliasName, "aliasName");
+  if (!this->ck().TrustedCertOf(aliasName.c_str(), caseSensitive, rt::implOf<HybridCert>(cert, "cert").ck())) throw this->fail("trustedCertOf");
+}
+
+void HybridJavaKeyStore::toPemObj(const std::string& password, const std::shared_ptr<HybridPemSpec>& pemObj) {
+  this->beginCall();
+  toPemObj_impl(password, pemObj);
+}
+void HybridJavaKeyStore::toPemObj_impl(const std::string& password, const std::shared_ptr<HybridPemSpec>& pemObj) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().ToPemObj(password.c_str(), rt::implOf<HybridPem>(pemObj, "pemObj").ck())) throw this->fail("toPemObj");
+}
+
+void HybridJavaKeyStore::toPfxObj(const std::string& password, const std::shared_ptr<HybridPfxSpec>& pfxObj) {
+  this->beginCall();
+  toPfxObj_impl(password, pfxObj);
+}
+void HybridJavaKeyStore::toPfxObj_impl(const std::string& password, const std::shared_ptr<HybridPfxSpec>& pfxObj) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().ToPfxObj(password.c_str(), rt::implOf<HybridPfx>(pfxObj, "pfxObj").ck())) throw this->fail("toPfxObj");
+}
+
+void HybridJavaKeyStore::toBd(const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  toBd_impl(password, bd);
+}
+void HybridJavaKeyStore::toBd_impl(const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().ToBd(password.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("toBd");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridJavaKeyStore.hpp

@@ -0,0 +1,98 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// JavaKeyStore: the Nitro HybridObject over Chilkat's CkJavaKeyStore (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridJavaKeyStoreSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkJavaKeyStore.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridJavaKeyStore final : public HybridJavaKeyStoreSpec, public ChilkatObject<CkJavaKeyStore> {
+public:
+  HybridJavaKeyStore();                                  // `new JavaKeyStore()` from JS
+  explicit HybridJavaKeyStore(CkJavaKeyStore* 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 getNumPrivateKeys() override;
+  double getNumTrustedCerts() override;
+  bool getRequireCompleteChain() override;
+  void setRequireCompleteChain(bool value) override;
+  bool getVerifyKeyedDigest() override;
+  void setVerifyKeyedDigest(bool value) override;
+  double getNumSecretKeys() override;
+
+  // ---- Methods ----
+  void addPfx(const std::shared_ptr<HybridPfxSpec>& pfx, const std::string& aliasName, const std::string& password) override;
+  void addPrivateKey(const std::shared_ptr<HybridCertSpec>& cert, const std::string& aliasName, const std::string& password) override;
+  void addTrustedCert(const std::shared_ptr<HybridCertSpec>& cert, const std::string& aliasName) override;
+  void changePassword(double index, const std::string& oldPassword, const std::string& newPassword) override;
+  std::string getPrivateKeyAlias(double index) override;
+  std::string getTrustedCertAlias(double index) override;
+  void loadEncoded(const std::string& password, const std::string& jksEncData, const std::string& encoding) override;
+  void loadFile(const std::string& password, const std::string& path) override;
+  void removeEntry(double entryType, double index) override;
+  void setAlias(double entryType, double index, const std::string& aliasName) override;
+  std::string toEncodedString(const std::string& password, const std::string& encoding) override;
+  void toFile(const std::string& password, const std::string& path) override;
+  void useCertVault(const std::shared_ptr<HybridXmlCertVaultSpec>& vault) override;
+  void toJwkSet(const std::string& password, const std::shared_ptr<HybridStringBuilderSpec>& sbJwkSet) override;
+  std::string getSecretKeyAlias(double index) override;
+  std::string getSecretKey(const std::string& password, double index, const std::string& encoding) override;
+  void addSecretKey(const std::string& encodedKeyBytes, const std::string& encoding, const std::string& algorithm, const std::string& aliasName, const std::string& password) override;
+  void loadJwkSet(const std::string& password, const std::shared_ptr<HybridJsonObjectSpec>& jwkSet) override;
+  void loadBd(const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void trustedCertAt(double index, const std::shared_ptr<HybridCertSpec>& cert) override;
+  void privateKeyAt(const std::string& password, double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey) override;
+  void certChainAt(double index, const std::shared_ptr<HybridCertChainSpec>& certChain) override;
+  void certChainOf(const std::string& aliasName, bool caseSensitive, const std::shared_ptr<HybridCertChainSpec>& certChain) override;
+  void privateKeyOf(const std::string& password, const std::string& aliasName, bool caseSensitive, const std::shared_ptr<HybridPrivateKeySpec>& privKey) override;
+  void trustedCertOf(const std::string& aliasName, bool caseSensitive, const std::shared_ptr<HybridCertSpec>& cert) override;
+  void toPemObj(const std::string& password, const std::shared_ptr<HybridPemSpec>& pemObj) override;
+  void toPfxObj(const std::string& password, const std::shared_ptr<HybridPfxSpec>& pfxObj) override;
+  void toBd(const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+
+private:
+  void init();
+  void addPfx_impl(const std::shared_ptr<HybridPfxSpec>& pfx, const std::string& aliasName, const std::string& password);
+  void addPrivateKey_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::string& aliasName, const std::string& password);
+  void addTrustedCert_impl(const std::shared_ptr<HybridCertSpec>& cert, const std::string& aliasName);
+  void changePassword_impl(double index, const std::string& oldPassword, const std::string& newPassword);
+  std::string getPrivateKeyAlias_impl(double index);
+  std::string getTrustedCertAlias_impl(double index);
+  void loadEncoded_impl(const std::string& password, const std::string& jksEncData, const std::string& encoding);
+  void loadFile_impl(const std::string& password, const std::string& path);
+  void removeEntry_impl(double entryType, double index);
+  void setAlias_impl(double entryType, double index, const std::string& aliasName);
+  std::string toEncodedString_impl(const std::string& password, const std::string& encoding);
+  void toFile_impl(const std::string& password, const std::string& path);
+  void useCertVault_impl(const std::shared_ptr<HybridXmlCertVaultSpec>& vault);
+  void toJwkSet_impl(const std::string& password, const std::shared_ptr<HybridStringBuilderSpec>& sbJwkSet);
+  std::string getSecretKeyAlias_impl(double index);
+  std::string getSecretKey_impl(const std::string& password, double index, const std::string& encoding);
+  void addSecretKey_impl(const std::string& encodedKeyBytes, const std::string& encoding, const std::string& algorithm, const std::string& aliasName, const std::string& password);
+  void loadJwkSet_impl(const std::string& password, const std::shared_ptr<HybridJsonObjectSpec>& jwkSet);
+  void loadBd_impl(const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd);
+  void trustedCertAt_impl(double index, const std::shared_ptr<HybridCertSpec>& cert);
+  void privateKeyAt_impl(const std::string& password, double index, const std::shared_ptr<HybridPrivateKeySpec>& privKey);
+  void certChainAt_impl(double index, const std::shared_ptr<HybridCertChainSpec>& certChain);
+  void certChainOf_impl(const std::string& aliasName, bool caseSensitive, const std::shared_ptr<HybridCertChainSpec>& certChain);
+  void privateKeyOf_impl(const std::string& password, const std::string& aliasName, bool caseSensitive, const std::shared_ptr<HybridPrivateKeySpec>& privKey);
+  void trustedCertOf_impl(const std::string& aliasName, bool caseSensitive, const std::shared_ptr<HybridCertSpec>& cert);
+  void toPemObj_impl(const std::string& password, const std::shared_ptr<HybridPemSpec>& pemObj);
+  void toPfxObj_impl(const std::string& password, const std::shared_ptr<HybridPfxSpec>& pfxObj);
+  void toBd_impl(const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridJs.cpp

@@ -0,0 +1,154 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridJs.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridJs::HybridJs()
+    : HybridObject(HybridJsSpec::TAG), ChilkatObject<CkJs>("Js", CkJs::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridJs::HybridJs(CkJs* owned)
+    : HybridObject(HybridJsSpec::TAG), ChilkatObject<CkJs>("Js", owned) {
+  init();
+}
+
+void HybridJs::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridJs::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridJs::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJs::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJs::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJs::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridJs::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridJs::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridJs::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridJs::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridJs::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridJs::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridJs::getTimeoutSeconds() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_TimeoutSeconds());
+}
+void HybridJs::setTimeoutSeconds(double value) {
+  this->beginCall();
+  this->ck().put_TimeoutSeconds(rt::toInt(value, "timeoutSeconds"));
+}
+
+// ---- Methods ----
+
+void HybridJs::eval(const std::shared_ptr<HybridStringBuilderSpec>& jscript, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) {
+  this->beginCall();
+  eval_impl(jscript, resultJson);
+}
+void HybridJs::eval_impl(const std::shared_ptr<HybridStringBuilderSpec>& jscript, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) {
+  if (!this->ck().Eval(rt::implOf<HybridStringBuilder>(jscript, "jscript").ck(), rt::implOf<HybridJsonObject>(resultJson, "resultJson").ck())) throw this->fail("eval");
+}
+std::shared_ptr<Promise<void>> HybridJs::evalAsync(const std::shared_ptr<HybridStringBuilderSpec>& jscript, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridJs>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(jscript);
+  _parts.push_back(resultJson);
+  return rt::runAsync<void>("Js.evalAsync", std::move(_parts), [_self, jscript, resultJson]() {
+    _self->eval_impl(jscript, resultJson);
+  });
+}
+
+void HybridJs::consoleOutputSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  consoleOutputSb_impl(sb);
+}
+void HybridJs::consoleOutputSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->ck().ConsoleOutputSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck());
+}
+
+void HybridJs::callFunction(const std::shared_ptr<HybridJsonObjectSpec>& funcJson, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) {
+  this->beginCall();
+  callFunction_impl(funcJson, resultJson);
+}
+void HybridJs::callFunction_impl(const std::shared_ptr<HybridJsonObjectSpec>& funcJson, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) {
+  if (!this->ck().CallFunction(rt::implOf<HybridJsonObject>(funcJson, "funcJson").ck(), rt::implOf<HybridJsonObject>(resultJson, "resultJson").ck())) throw this->fail("callFunction");
+}
+std::shared_ptr<Promise<void>> HybridJs::callFunctionAsync(const std::shared_ptr<HybridJsonObjectSpec>& funcJson, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridJs>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(funcJson);
+  _parts.push_back(resultJson);
+  return rt::runAsync<void>("Js.callFunctionAsync", std::move(_parts), [_self, funcJson, resultJson]() {
+    _self->callFunction_impl(funcJson, resultJson);
+  });
+}
+
+void HybridJs::setCkPermission(const std::string& chilkatClassName, const std::string& permission) {
+  this->beginCall();
+  setCkPermission_impl(chilkatClassName, permission);
+}
+void HybridJs::setCkPermission_impl(const std::string& chilkatClassName, const std::string& permission) {
+  rt::checkNoNul(chilkatClassName, "chilkatClassName");
+  rt::checkNoNul(permission, "permission");
+  if (!this->ck().SetCkPermission(chilkatClassName.c_str(), permission.c_str())) throw this->fail("setCkPermission");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridJs::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridJs::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridJs::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridJs::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridJs::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat