@chilkat/react-native 11.6.1

package/cpp/HybridPrivateKey.cpp

@@ -0,0 +1,464 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridPrivateKey.hpp"
+#include "HybridBinData.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridPublicKey.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridPrivateKey::HybridPrivateKey()
+    : HybridObject(HybridPrivateKeySpec::TAG), ChilkatObject<CkPrivateKey>("PrivateKey", CkPrivateKey::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridPrivateKey::HybridPrivateKey(CkPrivateKey* owned)
+    : HybridObject(HybridPrivateKeySpec::TAG), ChilkatObject<CkPrivateKey>("PrivateKey", owned) {
+  init();
+}
+
+void HybridPrivateKey::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridPrivateKey::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridPrivateKey::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPrivateKey::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPrivateKey::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPrivateKey::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPrivateKey::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridPrivateKey::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridPrivateKey::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridPrivateKey::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridPrivateKey::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridPrivateKey::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridPrivateKey::getBitLength() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_BitLength());
+}
+std::string HybridPrivateKey::getKeyType() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_KeyType(_s);
+  return rt::stdString(_s);
+}
+std::string HybridPrivateKey::getPkcs8EncryptAlg() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Pkcs8EncryptAlg(_s);
+  return rt::stdString(_s);
+}
+void HybridPrivateKey::setPkcs8EncryptAlg(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "pkcs8EncryptAlg");
+  this->ck().put_Pkcs8EncryptAlg(value.c_str());
+}
+std::string HybridPrivateKey::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridPrivateKey::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+std::string HybridPrivateKey::getPkcs1ENC(const std::string& encoding) {
+  this->beginCall();
+  return getPkcs1ENC_impl(encoding);
+}
+std::string HybridPrivateKey::getPkcs1ENC_impl(const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetPkcs1ENC(encoding.c_str(), _out)) throw this->fail("getPkcs1ENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridPrivateKey::getPkcs8ENC(const std::string& encoding) {
+  this->beginCall();
+  return getPkcs8ENC_impl(encoding);
+}
+std::string HybridPrivateKey::getPkcs8ENC_impl(const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetPkcs8ENC(encoding.c_str(), _out)) throw this->fail("getPkcs8ENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridPrivateKey::getPkcs8EncryptedENC(const std::string& encoding, const std::string& password) {
+  this->beginCall();
+  return getPkcs8EncryptedENC_impl(encoding, password);
+}
+std::string HybridPrivateKey::getPkcs8EncryptedENC_impl(const std::string& encoding, const std::string& password) {
+  rt::checkNoNul(encoding, "encoding");
+  rt::checkNoNul(password, "password");
+  CkString _out;
+  if (!this->ck().GetPkcs8EncryptedENC(encoding.c_str(), password.c_str(), _out)) throw this->fail("getPkcs8EncryptedENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridPrivateKey::getPkcs8EncryptedPem(const std::string& password) {
+  this->beginCall();
+  return getPkcs8EncryptedPem_impl(password);
+}
+std::string HybridPrivateKey::getPkcs8EncryptedPem_impl(const std::string& password) {
+  rt::checkNoNul(password, "password");
+  CkString _out;
+  if (!this->ck().GetPkcs8EncryptedPem(password.c_str(), _out)) throw this->fail("getPkcs8EncryptedPem");
+  return rt::stdString(_out);
+}
+
+std::string HybridPrivateKey::getPkcs8Pem() {
+  this->beginCall();
+  return getPkcs8Pem_impl();
+}
+std::string HybridPrivateKey::getPkcs8Pem_impl() {
+  CkString _out;
+  if (!this->ck().GetPkcs8Pem(_out)) throw this->fail("getPkcs8Pem");
+  return rt::stdString(_out);
+}
+
+std::string HybridPrivateKey::getXml() {
+  this->beginCall();
+  return getXml_impl();
+}
+std::string HybridPrivateKey::getXml_impl() {
+  CkString _out;
+  if (!this->ck().GetXml(_out)) throw this->fail("getXml");
+  return rt::stdString(_out);
+}
+
+void HybridPrivateKey::loadEncryptedPem(const std::string& pemStr, const std::string& password) {
+  this->beginCall();
+  loadEncryptedPem_impl(pemStr, password);
+}
+void HybridPrivateKey::loadEncryptedPem_impl(const std::string& pemStr, const std::string& password) {
+  rt::checkNoNul(pemStr, "pemStr");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadEncryptedPem(pemStr.c_str(), password.c_str())) throw this->fail("loadEncryptedPem");
+}
+
+void HybridPrivateKey::loadEncryptedPemFile(const std::string& path, const std::string& password) {
+  this->beginCall();
+  loadEncryptedPemFile_impl(path, password);
+}
+void HybridPrivateKey::loadEncryptedPemFile_impl(const std::string& path, const std::string& password) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadEncryptedPemFile(path.c_str(), password.c_str())) throw this->fail("loadEncryptedPemFile");
+}
+
+void HybridPrivateKey::loadPem(const std::string& str) {
+  this->beginCall();
+  loadPem_impl(str);
+}
+void HybridPrivateKey::loadPem_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  if (!this->ck().LoadPem(str.c_str())) throw this->fail("loadPem");
+}
+
+void HybridPrivateKey::loadPemFile(const std::string& path) {
+  this->beginCall();
+  loadPemFile_impl(path);
+}
+void HybridPrivateKey::loadPemFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().LoadPemFile(path.c_str())) throw this->fail("loadPemFile");
+}
+
+void HybridPrivateKey::loadPkcs8EncryptedFile(const std::string& path, const std::string& password) {
+  this->beginCall();
+  loadPkcs8EncryptedFile_impl(path, password);
+}
+void HybridPrivateKey::loadPkcs8EncryptedFile_impl(const std::string& path, const std::string& password) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadPkcs8EncryptedFile(path.c_str(), password.c_str())) throw this->fail("loadPkcs8EncryptedFile");
+}
+
+void HybridPrivateKey::loadPkcs8File(const std::string& path) {
+  this->beginCall();
+  loadPkcs8File_impl(path);
+}
+void HybridPrivateKey::loadPkcs8File_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().LoadPkcs8File(path.c_str())) throw this->fail("loadPkcs8File");
+}
+
+void HybridPrivateKey::loadPvkFile(const std::string& path, const std::string& password) {
+  this->beginCall();
+  loadPvkFile_impl(path, password);
+}
+void HybridPrivateKey::loadPvkFile_impl(const std::string& path, const std::string& password) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadPvkFile(path.c_str(), password.c_str())) throw this->fail("loadPvkFile");
+}
+
+void HybridPrivateKey::loadXml(const std::string& xml) {
+  this->beginCall();
+  loadXml_impl(xml);
+}
+void HybridPrivateKey::loadXml_impl(const std::string& xml) {
+  rt::checkNoNul(xml, "xml");
+  if (!this->ck().LoadXml(xml.c_str())) throw this->fail("loadXml");
+}
+
+void HybridPrivateKey::loadXmlFile(const std::string& path) {
+  this->beginCall();
+  loadXmlFile_impl(path);
+}
+void HybridPrivateKey::loadXmlFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().LoadXmlFile(path.c_str())) throw this->fail("loadXmlFile");
+}
+
+void HybridPrivateKey::savePkcs8EncryptedFile(const std::string& password, const std::string& path) {
+  this->beginCall();
+  savePkcs8EncryptedFile_impl(password, path);
+}
+void HybridPrivateKey::savePkcs8EncryptedFile_impl(const std::string& password, const std::string& path) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SavePkcs8EncryptedFile(password.c_str(), path.c_str())) throw this->fail("savePkcs8EncryptedFile");
+}
+
+void HybridPrivateKey::savePkcs8EncryptedPemFile(const std::string& password, const std::string& path) {
+  this->beginCall();
+  savePkcs8EncryptedPemFile_impl(password, path);
+}
+void HybridPrivateKey::savePkcs8EncryptedPemFile_impl(const std::string& password, const std::string& path) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SavePkcs8EncryptedPemFile(password.c_str(), path.c_str())) throw this->fail("savePkcs8EncryptedPemFile");
+}
+
+void HybridPrivateKey::savePkcs8File(const std::string& path) {
+  this->beginCall();
+  savePkcs8File_impl(path);
+}
+void HybridPrivateKey::savePkcs8File_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SavePkcs8File(path.c_str())) throw this->fail("savePkcs8File");
+}
+
+void HybridPrivateKey::savePkcs8PemFile(const std::string& path) {
+  this->beginCall();
+  savePkcs8PemFile_impl(path);
+}
+void HybridPrivateKey::savePkcs8PemFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SavePkcs8PemFile(path.c_str())) throw this->fail("savePkcs8PemFile");
+}
+
+void HybridPrivateKey::saveXmlFile(const std::string& path) {
+  this->beginCall();
+  saveXmlFile_impl(path);
+}
+void HybridPrivateKey::saveXmlFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SaveXmlFile(path.c_str())) throw this->fail("saveXmlFile");
+}
+
+std::string HybridPrivateKey::getPkcs1Pem() {
+  this->beginCall();
+  return getPkcs1Pem_impl();
+}
+std::string HybridPrivateKey::getPkcs1Pem_impl() {
+  CkString _out;
+  if (!this->ck().GetPkcs1Pem(_out)) throw this->fail("getPkcs1Pem");
+  return rt::stdString(_out);
+}
+
+void HybridPrivateKey::loadPkcs1File(const std::string& path) {
+  this->beginCall();
+  loadPkcs1File_impl(path);
+}
+void HybridPrivateKey::loadPkcs1File_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().LoadPkcs1File(path.c_str())) throw this->fail("loadPkcs1File");
+}
+
+void HybridPrivateKey::savePkcs1File(const std::string& path) {
+  this->beginCall();
+  savePkcs1File_impl(path);
+}
+void HybridPrivateKey::savePkcs1File_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SavePkcs1File(path.c_str())) throw this->fail("savePkcs1File");
+}
+
+void HybridPrivateKey::savePemFile(const std::string& path) {
+  this->beginCall();
+  savePemFile_impl(path);
+}
+void HybridPrivateKey::savePemFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SavePemFile(path.c_str())) throw this->fail("savePemFile");
+}
+
+std::string HybridPrivateKey::getJwk() {
+  this->beginCall();
+  return getJwk_impl();
+}
+std::string HybridPrivateKey::getJwk_impl() {
+  CkString _out;
+  if (!this->ck().GetJwk(_out)) throw this->fail("getJwk");
+  return rt::stdString(_out);
+}
+
+void HybridPrivateKey::loadJwk(const std::string& jsonStr) {
+  this->beginCall();
+  loadJwk_impl(jsonStr);
+}
+void HybridPrivateKey::loadJwk_impl(const std::string& jsonStr) {
+  rt::checkNoNul(jsonStr, "jsonStr");
+  if (!this->ck().LoadJwk(jsonStr.c_str())) throw this->fail("loadJwk");
+}
+
+std::string HybridPrivateKey::getJwkThumbprint(const std::string& hashAlg) {
+  this->beginCall();
+  return getJwkThumbprint_impl(hashAlg);
+}
+std::string HybridPrivateKey::getJwkThumbprint_impl(const std::string& hashAlg) {
+  rt::checkNoNul(hashAlg, "hashAlg");
+  CkString _out;
+  if (!this->ck().GetJwkThumbprint(hashAlg.c_str(), _out)) throw this->fail("getJwkThumbprint");
+  return rt::stdString(_out);
+}
+
+void HybridPrivateKey::loadAnyFormat(const std::shared_ptr<HybridBinDataSpec>& privKeyData, const std::string& password) {
+  this->beginCall();
+  loadAnyFormat_impl(privKeyData, password);
+}
+void HybridPrivateKey::loadAnyFormat_impl(const std::shared_ptr<HybridBinDataSpec>& privKeyData, const std::string& password) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadAnyFormat(rt::implOf<HybridBinData>(privKeyData, "privKeyData").ck(), password.c_str())) throw this->fail("loadAnyFormat");
+}
+
+void HybridPrivateKey::loadEd25519(const std::string& privKey, const std::string& pubKey) {
+  this->beginCall();
+  loadEd25519_impl(privKey, pubKey);
+}
+void HybridPrivateKey::loadEd25519_impl(const std::string& privKey, const std::string& pubKey) {
+  rt::checkNoNul(privKey, "privKey");
+  rt::checkNoNul(pubKey, "pubKey");
+  if (!this->ck().LoadEd25519(privKey.c_str(), pubKey.c_str())) throw this->fail("loadEd25519");
+}
+
+void HybridPrivateKey::loadAnyFormatFile(const std::string& path, const std::string& password) {
+  this->beginCall();
+  loadAnyFormatFile_impl(path, password);
+}
+void HybridPrivateKey::loadAnyFormatFile_impl(const std::string& path, const std::string& password) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().LoadAnyFormatFile(path.c_str(), password.c_str())) throw this->fail("loadAnyFormatFile");
+}
+
+std::string HybridPrivateKey::getRawHex(const std::shared_ptr<HybridStringBuilderSpec>& pubKey) {
+  this->beginCall();
+  return getRawHex_impl(pubKey);
+}
+std::string HybridPrivateKey::getRawHex_impl(const std::shared_ptr<HybridStringBuilderSpec>& pubKey) {
+  CkString _out;
+  if (!this->ck().GetRawHex(rt::implOf<HybridStringBuilder>(pubKey, "pubKey").ck(), _out)) throw this->fail("getRawHex");
+  return rt::stdString(_out);
+}
+
+void HybridPrivateKey::uploadToCloud(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) {
+  this->beginCall();
+  uploadToCloud_impl(jsonIn, jsonOut);
+}
+void HybridPrivateKey::uploadToCloud_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) {
+  if (!this->ck().UploadToCloud(rt::implOf<HybridJsonObject>(jsonIn, "jsonIn").ck(), rt::implOf<HybridJsonObject>(jsonOut, "jsonOut").ck())) throw this->fail("uploadToCloud");
+}
+std::shared_ptr<Promise<void>> HybridPrivateKey::uploadToCloudAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridPrivateKey>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(jsonIn);
+  _parts.push_back(jsonOut);
+  return rt::runAsync<void>("PrivateKey.uploadToCloudAsync", std::move(_parts), [_self, jsonIn, jsonOut]() {
+    _self->uploadToCloud_impl(jsonIn, jsonOut);
+  });
+}
+
+void HybridPrivateKey::toPublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubKey) {
+  this->beginCall();
+  toPublicKey_impl(pubKey);
+}
+void HybridPrivateKey::toPublicKey_impl(const std::shared_ptr<HybridPublicKeySpec>& pubKey) {
+  if (!this->ck().ToPublicKey(rt::implOf<HybridPublicKey>(pubKey, "pubKey").ck())) throw this->fail("toPublicKey");
+}
+
+void HybridPrivateKey::getPkcsBd(bool pkcs1, const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  getPkcsBd_impl(pkcs1, password, bd);
+}
+void HybridPrivateKey::getPkcsBd_impl(bool pkcs1, const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  rt::checkNoNul(password, "password");
+  if (!this->ck().GetPkcsBd(pkcs1, password.c_str(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("getPkcsBd");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridPrivateKey::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridPrivateKey::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridPrivateKey::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridPrivateKey::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridPrivateKey::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridPrivateKey.hpp

@@ -0,0 +1,117 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// PrivateKey: the Nitro HybridObject over Chilkat's CkPrivateKey (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridPrivateKeySpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkPrivateKey.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridPrivateKey final : public HybridPrivateKeySpec, public ChilkatObject<CkPrivateKey> {
+public:
+  HybridPrivateKey();                                  // `new PrivateKey()` from JS
+  explicit HybridPrivateKey(CkPrivateKey* 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 getBitLength() override;
+  std::string getKeyType() override;
+  std::string getPkcs8EncryptAlg() override;
+  void setPkcs8EncryptAlg(const std::string& value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+
+  // ---- Methods ----
+  std::string getPkcs1ENC(const std::string& encoding) override;
+  std::string getPkcs8ENC(const std::string& encoding) override;
+  std::string getPkcs8EncryptedENC(const std::string& encoding, const std::string& password) override;
+  std::string getPkcs8EncryptedPem(const std::string& password) override;
+  std::string getPkcs8Pem() override;
+  std::string getXml() override;
+  void loadEncryptedPem(const std::string& pemStr, const std::string& password) override;
+  void loadEncryptedPemFile(const std::string& path, const std::string& password) override;
+  void loadPem(const std::string& str) override;
+  void loadPemFile(const std::string& path) override;
+  void loadPkcs8EncryptedFile(const std::string& path, const std::string& password) override;
+  void loadPkcs8File(const std::string& path) override;
+  void loadPvkFile(const std::string& path, const std::string& password) override;
+  void loadXml(const std::string& xml) override;
+  void loadXmlFile(const std::string& path) override;
+  void savePkcs8EncryptedFile(const std::string& password, const std::string& path) override;
+  void savePkcs8EncryptedPemFile(const std::string& password, const std::string& path) override;
+  void savePkcs8File(const std::string& path) override;
+  void savePkcs8PemFile(const std::string& path) override;
+  void saveXmlFile(const std::string& path) override;
+  std::string getPkcs1Pem() override;
+  void loadPkcs1File(const std::string& path) override;
+  void savePkcs1File(const std::string& path) override;
+  void savePemFile(const std::string& path) override;
+  std::string getJwk() override;
+  void loadJwk(const std::string& jsonStr) override;
+  std::string getJwkThumbprint(const std::string& hashAlg) override;
+  void loadAnyFormat(const std::shared_ptr<HybridBinDataSpec>& privKeyData, const std::string& password) override;
+  void loadEd25519(const std::string& privKey, const std::string& pubKey) override;
+  void loadAnyFormatFile(const std::string& path, const std::string& password) override;
+  std::string getRawHex(const std::shared_ptr<HybridStringBuilderSpec>& pubKey) override;
+  void uploadToCloud(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  std::shared_ptr<Promise<void>> uploadToCloudAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  void toPublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubKey) override;
+  void getPkcsBd(bool pkcs1, const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+
+  // ---- Events (ReactNativeGen_DESIGN.md §6) ----
+  std::optional<std::function<void(double)>> getOnPercentDone() override;
+  void setOnPercentDone(const std::optional<std::function<void(double)>>& cb) override;
+  std::optional<std::function<void(const std::string&, const std::string&)>> getOnProgressInfo() override;
+  void setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) override;
+  void abort() override;
+
+private:
+  void init();
+  std::string getPkcs1ENC_impl(const std::string& encoding);
+  std::string getPkcs8ENC_impl(const std::string& encoding);
+  std::string getPkcs8EncryptedENC_impl(const std::string& encoding, const std::string& password);
+  std::string getPkcs8EncryptedPem_impl(const std::string& password);
+  std::string getPkcs8Pem_impl();
+  std::string getXml_impl();
+  void loadEncryptedPem_impl(const std::string& pemStr, const std::string& password);
+  void loadEncryptedPemFile_impl(const std::string& path, const std::string& password);
+  void loadPem_impl(const std::string& str);
+  void loadPemFile_impl(const std::string& path);
+  void loadPkcs8EncryptedFile_impl(const std::string& path, const std::string& password);
+  void loadPkcs8File_impl(const std::string& path);
+  void loadPvkFile_impl(const std::string& path, const std::string& password);
+  void loadXml_impl(const std::string& xml);
+  void loadXmlFile_impl(const std::string& path);
+  void savePkcs8EncryptedFile_impl(const std::string& password, const std::string& path);
+  void savePkcs8EncryptedPemFile_impl(const std::string& password, const std::string& path);
+  void savePkcs8File_impl(const std::string& path);
+  void savePkcs8PemFile_impl(const std::string& path);
+  void saveXmlFile_impl(const std::string& path);
+  std::string getPkcs1Pem_impl();
+  void loadPkcs1File_impl(const std::string& path);
+  void savePkcs1File_impl(const std::string& path);
+  void savePemFile_impl(const std::string& path);
+  std::string getJwk_impl();
+  void loadJwk_impl(const std::string& jsonStr);
+  std::string getJwkThumbprint_impl(const std::string& hashAlg);
+  void loadAnyFormat_impl(const std::shared_ptr<HybridBinDataSpec>& privKeyData, const std::string& password);
+  void loadEd25519_impl(const std::string& privKey, const std::string& pubKey);
+  void loadAnyFormatFile_impl(const std::string& path, const std::string& password);
+  std::string getRawHex_impl(const std::shared_ptr<HybridStringBuilderSpec>& pubKey);
+  void uploadToCloud_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonIn, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut);
+  void toPublicKey_impl(const std::shared_ptr<HybridPublicKeySpec>& pubKey);
+  void getPkcsBd_impl(bool pkcs1, const std::string& password, const std::shared_ptr<HybridBinDataSpec>& bd);
+};
+
+} // namespace margelo::nitro::chilkat