@chilkat/react-native 11.6.1

package/cpp/HybridDsa.cpp

@@ -0,0 +1,453 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridDsa.hpp"
+#include "HybridBinData.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridDsa::HybridDsa()
+    : HybridObject(HybridDsaSpec::TAG), ChilkatObject<CkDsa>("Dsa", CkDsa::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridDsa::HybridDsa(CkDsa* owned)
+    : HybridObject(HybridDsaSpec::TAG), ChilkatObject<CkDsa>("Dsa", owned) {
+  init();
+}
+
+void HybridDsa::init() {
+}
+
+void HybridDsa::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridDsa::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDsa::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDsa::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDsa::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDsa::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridDsa::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridDsa::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridDsa::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridDsa::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridDsa::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridDsa::getGroupSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_GroupSize());
+}
+void HybridDsa::setGroupSize(double value) {
+  this->beginCall();
+  this->ck().put_GroupSize(rt::toInt(value, "groupSize"));
+}
+std::string HybridDsa::getHexG() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HexG(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDsa::getHexP() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HexP(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDsa::getHexQ() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HexQ(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDsa::getHexX() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HexX(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDsa::getHexY() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HexY(_s);
+  return rt::stdString(_s);
+}
+std::string HybridDsa::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridDsa::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+
+// ---- Methods ----
+
+void HybridDsa::fromDerFile(const std::string& path) {
+  this->beginCall();
+  fromDerFile_impl(path);
+}
+void HybridDsa::fromDerFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().FromDerFile(path.c_str())) throw this->fail("fromDerFile");
+}
+
+void HybridDsa::fromEncryptedPem(const std::string& password, const std::string& pemData) {
+  this->beginCall();
+  fromEncryptedPem_impl(password, pemData);
+}
+void HybridDsa::fromEncryptedPem_impl(const std::string& password, const std::string& pemData) {
+  rt::checkNoNul(password, "password");
+  rt::checkNoNul(pemData, "pemData");
+  if (!this->ck().FromEncryptedPem(password.c_str(), pemData.c_str())) throw this->fail("fromEncryptedPem");
+}
+
+void HybridDsa::fromPem(const std::string& pemData) {
+  this->beginCall();
+  fromPem_impl(pemData);
+}
+void HybridDsa::fromPem_impl(const std::string& pemData) {
+  rt::checkNoNul(pemData, "pemData");
+  if (!this->ck().FromPem(pemData.c_str())) throw this->fail("fromPem");
+}
+
+void HybridDsa::fromPublicDerFile(const std::string& path) {
+  this->beginCall();
+  fromPublicDerFile_impl(path);
+}
+void HybridDsa::fromPublicDerFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().FromPublicDerFile(path.c_str())) throw this->fail("fromPublicDerFile");
+}
+
+void HybridDsa::fromPublicPem(const std::string& pemData) {
+  this->beginCall();
+  fromPublicPem_impl(pemData);
+}
+void HybridDsa::fromPublicPem_impl(const std::string& pemData) {
+  rt::checkNoNul(pemData, "pemData");
+  if (!this->ck().FromPublicPem(pemData.c_str())) throw this->fail("fromPublicPem");
+}
+
+void HybridDsa::fromXml(const std::string& xmlKey) {
+  this->beginCall();
+  fromXml_impl(xmlKey);
+}
+void HybridDsa::fromXml_impl(const std::string& xmlKey) {
+  rt::checkNoNul(xmlKey, "xmlKey");
+  if (!this->ck().FromXml(xmlKey.c_str())) throw this->fail("fromXml");
+}
+
+void HybridDsa::genKey(double numBits) {
+  this->beginCall();
+  genKey_impl(numBits);
+}
+void HybridDsa::genKey_impl(double numBits) {
+  if (!this->ck().GenKey(rt::toInt(numBits, "numBits"))) throw this->fail("genKey");
+}
+
+void HybridDsa::genKeyFromParamsDerFile(const std::string& path) {
+  this->beginCall();
+  genKeyFromParamsDerFile_impl(path);
+}
+void HybridDsa::genKeyFromParamsDerFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().GenKeyFromParamsDerFile(path.c_str())) throw this->fail("genKeyFromParamsDerFile");
+}
+
+void HybridDsa::genKeyFromParamsPem(const std::string& pem) {
+  this->beginCall();
+  genKeyFromParamsPem_impl(pem);
+}
+void HybridDsa::genKeyFromParamsPem_impl(const std::string& pem) {
+  rt::checkNoNul(pem, "pem");
+  if (!this->ck().GenKeyFromParamsPem(pem.c_str())) throw this->fail("genKeyFromParamsPem");
+}
+
+void HybridDsa::genKeyFromParamsPemFile(const std::string& path) {
+  this->beginCall();
+  genKeyFromParamsPemFile_impl(path);
+}
+void HybridDsa::genKeyFromParamsPemFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().GenKeyFromParamsPemFile(path.c_str())) throw this->fail("genKeyFromParamsPemFile");
+}
+
+std::string HybridDsa::getEncodedHash(const std::string& encoding) {
+  this->beginCall();
+  return getEncodedHash_impl(encoding);
+}
+std::string HybridDsa::getEncodedHash_impl(const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetEncodedHash(encoding.c_str(), _out)) throw this->fail("getEncodedHash");
+  return rt::stdString(_out);
+}
+
+std::string HybridDsa::getEncodedSignature(const std::string& encoding) {
+  this->beginCall();
+  return getEncodedSignature_impl(encoding);
+}
+std::string HybridDsa::getEncodedSignature_impl(const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetEncodedSignature(encoding.c_str(), _out)) throw this->fail("getEncodedSignature");
+  return rt::stdString(_out);
+}
+
+std::string HybridDsa::loadText(const std::string& path) {
+  this->beginCall();
+  return loadText_impl(path);
+}
+std::string HybridDsa::loadText_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  CkString _out;
+  if (!this->ck().LoadText(path.c_str(), _out)) throw this->fail("loadText");
+  return rt::stdString(_out);
+}
+
+void HybridDsa::saveText(const std::string& strToSave, const std::string& path) {
+  this->beginCall();
+  saveText_impl(strToSave, path);
+}
+void HybridDsa::saveText_impl(const std::string& strToSave, const std::string& path) {
+  rt::checkNoNul(strToSave, "strToSave");
+  rt::checkNoNul(path, "path");
+  if (!this->ck().SaveText(strToSave.c_str(), path.c_str())) throw this->fail("saveText");
+}
+
+void HybridDsa::setEncodedHash(const std::string& encoding, const std::string& encodedHash) {
+  this->beginCall();
+  setEncodedHash_impl(encoding, encodedHash);
+}
+void HybridDsa::setEncodedHash_impl(const std::string& encoding, const std::string& encodedHash) {
+  rt::checkNoNul(encoding, "encoding");
+  rt::checkNoNul(encodedHash, "encodedHash");
+  if (!this->ck().SetEncodedHash(encoding.c_str(), encodedHash.c_str())) throw this->fail("setEncodedHash");
+}
+
+void HybridDsa::setEncodedSignature(const std::string& encoding, const std::string& encodedSig) {
+  this->beginCall();
+  setEncodedSignature_impl(encoding, encodedSig);
+}
+void HybridDsa::setEncodedSignature_impl(const std::string& encoding, const std::string& encodedSig) {
+  rt::checkNoNul(encoding, "encoding");
+  rt::checkNoNul(encodedSig, "encodedSig");
+  if (!this->ck().SetEncodedSignature(encoding.c_str(), encodedSig.c_str())) throw this->fail("setEncodedSignature");
+}
+
+void HybridDsa::setEncodedSignatureRS(const std::string& encoding, const std::string& encodedR, const std::string& encodedS) {
+  this->beginCall();
+  setEncodedSignatureRS_impl(encoding, encodedR, encodedS);
+}
+void HybridDsa::setEncodedSignatureRS_impl(const std::string& encoding, const std::string& encodedR, const std::string& encodedS) {
+  rt::checkNoNul(encoding, "encoding");
+  rt::checkNoNul(encodedR, "encodedR");
+  rt::checkNoNul(encodedS, "encodedS");
+  if (!this->ck().SetEncodedSignatureRS(encoding.c_str(), encodedR.c_str(), encodedS.c_str())) throw this->fail("setEncodedSignatureRS");
+}
+
+void HybridDsa::setKeyExplicit(double groupSizeInBytes, const std::string& pHex, const std::string& qHex, const std::string& gHex, const std::string& xHex) {
+  this->beginCall();
+  setKeyExplicit_impl(groupSizeInBytes, pHex, qHex, gHex, xHex);
+}
+void HybridDsa::setKeyExplicit_impl(double groupSizeInBytes, const std::string& pHex, const std::string& qHex, const std::string& gHex, const std::string& xHex) {
+  rt::checkNoNul(pHex, "pHex");
+  rt::checkNoNul(qHex, "qHex");
+  rt::checkNoNul(gHex, "gHex");
+  rt::checkNoNul(xHex, "xHex");
+  if (!this->ck().SetKeyExplicit(rt::toInt(groupSizeInBytes, "groupSizeInBytes"), pHex.c_str(), qHex.c_str(), gHex.c_str(), xHex.c_str())) throw this->fail("setKeyExplicit");
+}
+
+void HybridDsa::setPubKeyExplicit(double groupSizeInBytes, const std::string& pHex, const std::string& qHex, const std::string& gHex, const std::string& yHex) {
+  this->beginCall();
+  setPubKeyExplicit_impl(groupSizeInBytes, pHex, qHex, gHex, yHex);
+}
+void HybridDsa::setPubKeyExplicit_impl(double groupSizeInBytes, const std::string& pHex, const std::string& qHex, const std::string& gHex, const std::string& yHex) {
+  rt::checkNoNul(pHex, "pHex");
+  rt::checkNoNul(qHex, "qHex");
+  rt::checkNoNul(gHex, "gHex");
+  rt::checkNoNul(yHex, "yHex");
+  if (!this->ck().SetPubKeyExplicit(rt::toInt(groupSizeInBytes, "groupSizeInBytes"), pHex.c_str(), qHex.c_str(), gHex.c_str(), yHex.c_str())) throw this->fail("setPubKeyExplicit");
+}
+
+void HybridDsa::signHash() {
+  this->beginCall();
+  signHash_impl();
+}
+void HybridDsa::signHash_impl() {
+  if (!this->ck().SignHash()) throw this->fail("signHash");
+}
+
+void HybridDsa::toDerFile(const std::string& path) {
+  this->beginCall();
+  toDerFile_impl(path);
+}
+void HybridDsa::toDerFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().ToDerFile(path.c_str())) throw this->fail("toDerFile");
+}
+
+std::string HybridDsa::toEncryptedPem(const std::string& password) {
+  this->beginCall();
+  return toEncryptedPem_impl(password);
+}
+std::string HybridDsa::toEncryptedPem_impl(const std::string& password) {
+  rt::checkNoNul(password, "password");
+  CkString _out;
+  if (!this->ck().ToEncryptedPem(password.c_str(), _out)) throw this->fail("toEncryptedPem");
+  return rt::stdString(_out);
+}
+
+std::string HybridDsa::toPem() {
+  this->beginCall();
+  return toPem_impl();
+}
+std::string HybridDsa::toPem_impl() {
+  CkString _out;
+  if (!this->ck().ToPem(_out)) throw this->fail("toPem");
+  return rt::stdString(_out);
+}
+
+void HybridDsa::toPublicDerFile(const std::string& path) {
+  this->beginCall();
+  toPublicDerFile_impl(path);
+}
+void HybridDsa::toPublicDerFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().ToPublicDerFile(path.c_str())) throw this->fail("toPublicDerFile");
+}
+
+std::string HybridDsa::toPublicPem() {
+  this->beginCall();
+  return toPublicPem_impl();
+}
+std::string HybridDsa::toPublicPem_impl() {
+  CkString _out;
+  if (!this->ck().ToPublicPem(_out)) throw this->fail("toPublicPem");
+  return rt::stdString(_out);
+}
+
+std::string HybridDsa::toXml(bool bPublicOnly) {
+  this->beginCall();
+  return toXml_impl(bPublicOnly);
+}
+std::string HybridDsa::toXml_impl(bool bPublicOnly) {
+  CkString _out;
+  if (!this->ck().ToXml(bPublicOnly, _out)) throw this->fail("toXml");
+  return rt::stdString(_out);
+}
+
+void HybridDsa::verify() {
+  this->beginCall();
+  verify_impl();
+}
+void HybridDsa::verify_impl() {
+  if (!this->ck().Verify()) throw this->fail("verify");
+}
+
+bool HybridDsa::verifyKey() {
+  this->beginCall();
+  return verifyKey_impl();
+}
+bool HybridDsa::verifyKey_impl() {
+  return this->ck().VerifyKey();
+}
+
+void HybridDsa::genKey2(double keyLenBits, double modLenBits) {
+  this->beginCall();
+  genKey2_impl(keyLenBits, modLenBits);
+}
+void HybridDsa::genKey2_impl(double keyLenBits, double modLenBits) {
+  if (!this->ck().GenKey2(rt::toInt(keyLenBits, "keyLenBits"), rt::toInt(modLenBits, "modLenBits"))) throw this->fail("genKey2");
+}
+
+void HybridDsa::genKeyFromPQG(const std::string& pHex, const std::string& qHex, const std::string& gHex) {
+  this->beginCall();
+  genKeyFromPQG_impl(pHex, qHex, gHex);
+}
+void HybridDsa::genKeyFromPQG_impl(const std::string& pHex, const std::string& qHex, const std::string& gHex) {
+  rt::checkNoNul(pHex, "pHex");
+  rt::checkNoNul(qHex, "qHex");
+  rt::checkNoNul(gHex, "gHex");
+  if (!this->ck().GenKeyFromPQG(pHex.c_str(), qHex.c_str(), gHex.c_str())) throw this->fail("genKeyFromPQG");
+}
+
+void HybridDsa::fromDerBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  fromDerBd_impl(bd);
+}
+void HybridDsa::fromDerBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().FromDerBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("fromDerBd");
+}
+
+void HybridDsa::fromPublicDerBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  fromPublicDerBd_impl(bd);
+}
+void HybridDsa::fromPublicDerBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().FromPublicDerBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("fromPublicDerBd");
+}
+
+void HybridDsa::genKeyFromParamsDerBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  genKeyFromParamsDerBd_impl(bd);
+}
+void HybridDsa::genKeyFromParamsDerBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().GenKeyFromParamsDerBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("genKeyFromParamsDerBd");
+}
+
+void HybridDsa::toDerBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  toDerBd_impl(bd);
+}
+void HybridDsa::toDerBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().ToDerBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("toDerBd");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridDsa.hpp

@@ -0,0 +1,112 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Dsa: the Nitro HybridObject over Chilkat's CkDsa (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridDsaSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkDsa.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridDsa final : public HybridDsaSpec, public ChilkatObject<CkDsa> {
+public:
+  HybridDsa();                                  // `new Dsa()` from JS
+  explicit HybridDsa(CkDsa* 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 getGroupSize() override;
+  void setGroupSize(double value) override;
+  std::string getHexG() override;
+  std::string getHexP() override;
+  std::string getHexQ() override;
+  std::string getHexX() override;
+  std::string getHexY() override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+
+  // ---- Methods ----
+  void fromDerFile(const std::string& path) override;
+  void fromEncryptedPem(const std::string& password, const std::string& pemData) override;
+  void fromPem(const std::string& pemData) override;
+  void fromPublicDerFile(const std::string& path) override;
+  void fromPublicPem(const std::string& pemData) override;
+  void fromXml(const std::string& xmlKey) override;
+  void genKey(double numBits) override;
+  void genKeyFromParamsDerFile(const std::string& path) override;
+  void genKeyFromParamsPem(const std::string& pem) override;
+  void genKeyFromParamsPemFile(const std::string& path) override;
+  std::string getEncodedHash(const std::string& encoding) override;
+  std::string getEncodedSignature(const std::string& encoding) override;
+  std::string loadText(const std::string& path) override;
+  void saveText(const std::string& strToSave, const std::string& path) override;
+  void setEncodedHash(const std::string& encoding, const std::string& encodedHash) override;
+  void setEncodedSignature(const std::string& encoding, const std::string& encodedSig) override;
+  void setEncodedSignatureRS(const std::string& encoding, const std::string& encodedR, const std::string& encodedS) override;
+  void setKeyExplicit(double groupSizeInBytes, const std::string& pHex, const std::string& qHex, const std::string& gHex, const std::string& xHex) override;
+  void setPubKeyExplicit(double groupSizeInBytes, const std::string& pHex, const std::string& qHex, const std::string& gHex, const std::string& yHex) override;
+  void signHash() override;
+  void toDerFile(const std::string& path) override;
+  std::string toEncryptedPem(const std::string& password) override;
+  std::string toPem() override;
+  void toPublicDerFile(const std::string& path) override;
+  std::string toPublicPem() override;
+  std::string toXml(bool bPublicOnly) override;
+  void verify() override;
+  bool verifyKey() override;
+  void genKey2(double keyLenBits, double modLenBits) override;
+  void genKeyFromPQG(const std::string& pHex, const std::string& qHex, const std::string& gHex) override;
+  void fromDerBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void fromPublicDerBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void genKeyFromParamsDerBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void toDerBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+
+private:
+  void init();
+  void fromDerFile_impl(const std::string& path);
+  void fromEncryptedPem_impl(const std::string& password, const std::string& pemData);
+  void fromPem_impl(const std::string& pemData);
+  void fromPublicDerFile_impl(const std::string& path);
+  void fromPublicPem_impl(const std::string& pemData);
+  void fromXml_impl(const std::string& xmlKey);
+  void genKey_impl(double numBits);
+  void genKeyFromParamsDerFile_impl(const std::string& path);
+  void genKeyFromParamsPem_impl(const std::string& pem);
+  void genKeyFromParamsPemFile_impl(const std::string& path);
+  std::string getEncodedHash_impl(const std::string& encoding);
+  std::string getEncodedSignature_impl(const std::string& encoding);
+  std::string loadText_impl(const std::string& path);
+  void saveText_impl(const std::string& strToSave, const std::string& path);
+  void setEncodedHash_impl(const std::string& encoding, const std::string& encodedHash);
+  void setEncodedSignature_impl(const std::string& encoding, const std::string& encodedSig);
+  void setEncodedSignatureRS_impl(const std::string& encoding, const std::string& encodedR, const std::string& encodedS);
+  void setKeyExplicit_impl(double groupSizeInBytes, const std::string& pHex, const std::string& qHex, const std::string& gHex, const std::string& xHex);
+  void setPubKeyExplicit_impl(double groupSizeInBytes, const std::string& pHex, const std::string& qHex, const std::string& gHex, const std::string& yHex);
+  void signHash_impl();
+  void toDerFile_impl(const std::string& path);
+  std::string toEncryptedPem_impl(const std::string& password);
+  std::string toPem_impl();
+  void toPublicDerFile_impl(const std::string& path);
+  std::string toPublicPem_impl();
+  std::string toXml_impl(bool bPublicOnly);
+  void verify_impl();
+  bool verifyKey_impl();
+  void genKey2_impl(double keyLenBits, double modLenBits);
+  void genKeyFromPQG_impl(const std::string& pHex, const std::string& qHex, const std::string& gHex);
+  void fromDerBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  void fromPublicDerBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  void genKeyFromParamsDerBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  void toDerBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+};
+
+} // namespace margelo::nitro::chilkat