@chilkat/react-native 11.6.1

package/cpp/HybridRest.hpp

@@ -0,0 +1,214 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Rest: the Nitro HybridObject over Chilkat's CkRest (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridRestSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkRest.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridRest final : public HybridRestSpec, public ChilkatObject<CkRest> {
+public:
+  HybridRest();                                  // `new Rest()` from JS
+  explicit HybridRest(CkRest* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  std::string getAuthorization() override;
+  void setAuthorization(const std::string& value) override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+  std::string getHost() override;
+  void setHost(const std::string& value) override;
+  double getIdleTimeoutMs() override;
+  void setIdleTimeoutMs(double value) override;
+  std::string getLastRequestHeader() override;
+  std::string getLastRequestStartLine() override;
+  double getNumResponseHeaders() override;
+  std::string getPartSelector() override;
+  void setPartSelector(const std::string& value) override;
+  std::string getResponseHeader() override;
+  double getResponseStatusCode() override;
+  std::string getResponseStatusText() override;
+  bool getStreamNonChunked() override;
+  void setStreamNonChunked(bool value) override;
+  double getConnectFailReason() override;
+  bool getPercentDoneOnSend() override;
+  void setPercentDoneOnSend(bool value) override;
+  bool getAllowHeaderQB() override;
+  void setAllowHeaderQB(bool value) override;
+  bool getAllowHeaderFolding() override;
+  void setAllowHeaderFolding(bool value) override;
+  double getConnectTimeoutMs() override;
+  void setConnectTimeoutMs(double value) override;
+  bool getDebugMode() override;
+  void setDebugMode(bool value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+  std::string getLastRedirectUrl() override;
+  bool getEnableSecrets() override;
+  void setEnableSecrets(bool value) override;
+
+  // ---- Methods ----
+  void addHeader(const std::string& name, const std::string& value) override;
+  void addQueryParam(const std::string& name, const std::string& value) override;
+  void addQueryParams(const std::string& queryString) override;
+  void clearAllHeaders() override;
+  void clearAllQueryParams() override;
+  void clearResponseBodyStream() override;
+  void connect(const std::string& hostname, double port, bool tls, bool autoReconnect) override;
+  std::shared_ptr<Promise<void>> connectAsync(const std::string& hostname, double port, bool tls, bool autoReconnect) override;
+  void disconnect(double maxWaitMs) override;
+  std::shared_ptr<Promise<void>> disconnectAsync(double maxWaitMs) override;
+  std::string fullRequestFormUrlEncoded(const std::string& httpVerb, const std::string& uriPath) override;
+  std::shared_ptr<Promise<std::string>> fullRequestFormUrlEncodedAsync(const std::string& httpVerb, const std::string& uriPath) override;
+  std::string fullRequestMultipart(const std::string& httpVerb, const std::string& uriPath) override;
+  std::shared_ptr<Promise<std::string>> fullRequestMultipartAsync(const std::string& httpVerb, const std::string& uriPath) override;
+  std::string fullRequestNoBody(const std::string& httpVerb, const std::string& uriPath) override;
+  std::shared_ptr<Promise<std::string>> fullRequestNoBodyAsync(const std::string& httpVerb, const std::string& uriPath) override;
+  std::string fullRequestStream(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream) override;
+  std::shared_ptr<Promise<std::string>> fullRequestStreamAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream) override;
+  std::string fullRequestString(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText) override;
+  std::shared_ptr<Promise<std::string>> fullRequestStringAsync(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText) override;
+  void readRespBodyStream(const std::shared_ptr<HybridStreamSpec>& stream, bool autoSetStreamCharset) override;
+  std::shared_ptr<Promise<void>> readRespBodyStreamAsync(const std::shared_ptr<HybridStreamSpec>& stream, bool autoSetStreamCharset) override;
+  std::string readRespBodyString() override;
+  std::shared_ptr<Promise<std::string>> readRespBodyStringAsync() override;
+  double readResponseHeader() override;
+  std::shared_ptr<Promise<double>> readResponseHeaderAsync() override;
+  void removeHeader(const std::string& name) override;
+  void removeQueryParam(const std::string& name) override;
+  std::string responseHdrByName(const std::string& name) override;
+  std::string responseHdrName(double index) override;
+  std::string responseHdrValue(double index) override;
+  void sendReqFormUrlEncoded(const std::string& httpVerb, const std::string& uriPath) override;
+  std::shared_ptr<Promise<void>> sendReqFormUrlEncodedAsync(const std::string& httpVerb, const std::string& uriPath) override;
+  void sendReqMultipart(const std::string& httpVerb, const std::string& uriPath) override;
+  std::shared_ptr<Promise<void>> sendReqMultipartAsync(const std::string& httpVerb, const std::string& uriPath) override;
+  void sendReqNoBody(const std::string& httpVerb, const std::string& uriPath) override;
+  std::shared_ptr<Promise<void>> sendReqNoBodyAsync(const std::string& httpVerb, const std::string& uriPath) override;
+  void sendReqStreamBody(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream) override;
+  std::shared_ptr<Promise<void>> sendReqStreamBodyAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream) override;
+  void sendReqStringBody(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText) override;
+  std::shared_ptr<Promise<void>> sendReqStringBodyAsync(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText) override;
+  void setAuthAws(const std::shared_ptr<HybridAuthAwsSpec>& authProvider) override;
+  void setAuthAzureStorage(const std::shared_ptr<HybridAuthAzureStorageSpec>& authProvider) override;
+  void setAuthBasic(const std::string& username, const std::string& password) override;
+  void setAuthGoogle(const std::shared_ptr<HybridAuthGoogleSpec>& authProvider) override;
+  void setAuthOAuth1(const std::shared_ptr<HybridOAuth1Spec>& authProvider, bool useQueryParams) override;
+  void setAuthOAuth2(const std::shared_ptr<HybridOAuth2Spec>& authProvider) override;
+  void setMultipartBodyStream(const std::shared_ptr<HybridStreamSpec>& stream) override;
+  void setMultipartBodyString(const std::string& bodyText) override;
+  void setResponseBodyStream(double expectedStatus, bool autoSetStreamCharset, const std::shared_ptr<HybridStreamSpec>& responseStream) override;
+  void useConnection(const std::shared_ptr<HybridSocketSpec>& connection, bool autoReconnect) override;
+  void fullRequestSb(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& requestBody, const std::shared_ptr<HybridStringBuilderSpec>& responseBody) override;
+  std::shared_ptr<Promise<void>> fullRequestSbAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& requestBody, const std::shared_ptr<HybridStringBuilderSpec>& responseBody) override;
+  void addQueryParamSb(const std::string& name, const std::shared_ptr<HybridStringBuilderSpec>& value) override;
+  void setMultipartBodySb(const std::shared_ptr<HybridStringBuilderSpec>& bodySb) override;
+  void setMultipartBodyBd(const std::shared_ptr<HybridBinDataSpec>& bodyData) override;
+  void sendReqSb(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& bodySb) override;
+  std::shared_ptr<Promise<void>> sendReqSbAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& bodySb) override;
+  void sendReqBd(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& body) override;
+  std::shared_ptr<Promise<void>> sendReqBdAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& body) override;
+  void readRespSb(const std::shared_ptr<HybridStringBuilderSpec>& responseBody) override;
+  std::shared_ptr<Promise<void>> readRespSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& responseBody) override;
+  void readRespBd(const std::shared_ptr<HybridBinDataSpec>& responseBody) override;
+  std::shared_ptr<Promise<void>> readRespBdAsync(const std::shared_ptr<HybridBinDataSpec>& responseBody) override;
+  void clearAllParts() override;
+  void fullRequestNoBodySb(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  std::shared_ptr<Promise<void>> fullRequestNoBodySbAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void fullRequestBd(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& responseBody) override;
+  std::shared_ptr<Promise<void>> fullRequestBdAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& responseBody) override;
+  void fullRequestNoBodyBd(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  std::shared_ptr<Promise<void>> fullRequestNoBodyBdAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData) override;
+  void setAuthAzureSas(const std::shared_ptr<HybridAuthAzureSASSpec>& authProvider) override;
+  void addMwsSignature(const std::string& httpVerb, const std::string& uriPath, const std::string& domain, const std::string& mwsSecretKey) override;
+  void clearAuth() override;
+  void addPathParam(const std::string& name, const std::string& value) override;
+  void clearAllPathParams() override;
+  void setAuthBasicSecure(const std::shared_ptr<HybridSecureStringSpec>& username, const std::shared_ptr<HybridSecureStringSpec>& password) override;
+  void getLastDebugRequest(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  double readRespChunkBd(double minSize, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  std::shared_ptr<Promise<double>> readRespChunkBdAsync(double minSize, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) 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();
+  void addHeader_impl(const std::string& name, const std::string& value);
+  void addQueryParam_impl(const std::string& name, const std::string& value);
+  void addQueryParams_impl(const std::string& queryString);
+  void clearAllHeaders_impl();
+  void clearAllQueryParams_impl();
+  void clearResponseBodyStream_impl();
+  void connect_impl(const std::string& hostname, double port, bool tls, bool autoReconnect);
+  void disconnect_impl(double maxWaitMs);
+  std::string fullRequestFormUrlEncoded_impl(const std::string& httpVerb, const std::string& uriPath);
+  std::string fullRequestMultipart_impl(const std::string& httpVerb, const std::string& uriPath);
+  std::string fullRequestNoBody_impl(const std::string& httpVerb, const std::string& uriPath);
+  std::string fullRequestStream_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream);
+  std::string fullRequestString_impl(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText);
+  void readRespBodyStream_impl(const std::shared_ptr<HybridStreamSpec>& stream, bool autoSetStreamCharset);
+  std::string readRespBodyString_impl();
+  double readResponseHeader_impl();
+  void removeHeader_impl(const std::string& name);
+  void removeQueryParam_impl(const std::string& name);
+  std::string responseHdrByName_impl(const std::string& name);
+  std::string responseHdrName_impl(double index);
+  std::string responseHdrValue_impl(double index);
+  void sendReqFormUrlEncoded_impl(const std::string& httpVerb, const std::string& uriPath);
+  void sendReqMultipart_impl(const std::string& httpVerb, const std::string& uriPath);
+  void sendReqNoBody_impl(const std::string& httpVerb, const std::string& uriPath);
+  void sendReqStreamBody_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream);
+  void sendReqStringBody_impl(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText);
+  void setAuthAws_impl(const std::shared_ptr<HybridAuthAwsSpec>& authProvider);
+  void setAuthAzureStorage_impl(const std::shared_ptr<HybridAuthAzureStorageSpec>& authProvider);
+  void setAuthBasic_impl(const std::string& username, const std::string& password);
+  void setAuthGoogle_impl(const std::shared_ptr<HybridAuthGoogleSpec>& authProvider);
+  void setAuthOAuth1_impl(const std::shared_ptr<HybridOAuth1Spec>& authProvider, bool useQueryParams);
+  void setAuthOAuth2_impl(const std::shared_ptr<HybridOAuth2Spec>& authProvider);
+  void setMultipartBodyStream_impl(const std::shared_ptr<HybridStreamSpec>& stream);
+  void setMultipartBodyString_impl(const std::string& bodyText);
+  void setResponseBodyStream_impl(double expectedStatus, bool autoSetStreamCharset, const std::shared_ptr<HybridStreamSpec>& responseStream);
+  void useConnection_impl(const std::shared_ptr<HybridSocketSpec>& connection, bool autoReconnect);
+  void fullRequestSb_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& requestBody, const std::shared_ptr<HybridStringBuilderSpec>& responseBody);
+  void addQueryParamSb_impl(const std::string& name, const std::shared_ptr<HybridStringBuilderSpec>& value);
+  void setMultipartBodySb_impl(const std::shared_ptr<HybridStringBuilderSpec>& bodySb);
+  void setMultipartBodyBd_impl(const std::shared_ptr<HybridBinDataSpec>& bodyData);
+  void sendReqSb_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& bodySb);
+  void sendReqBd_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& body);
+  void readRespSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& responseBody);
+  void readRespBd_impl(const std::shared_ptr<HybridBinDataSpec>& responseBody);
+  void clearAllParts_impl();
+  void fullRequestNoBodySb_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void fullRequestBd_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& responseBody);
+  void fullRequestNoBodyBd_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData);
+  void setAuthAzureSas_impl(const std::shared_ptr<HybridAuthAzureSASSpec>& authProvider);
+  void addMwsSignature_impl(const std::string& httpVerb, const std::string& uriPath, const std::string& domain, const std::string& mwsSecretKey);
+  void clearAuth_impl();
+  void addPathParam_impl(const std::string& name, const std::string& value);
+  void clearAllPathParams_impl();
+  void setAuthBasicSecure_impl(const std::shared_ptr<HybridSecureStringSpec>& username, const std::shared_ptr<HybridSecureStringSpec>& password);
+  void getLastDebugRequest_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  double readRespChunkBd_impl(double minSize, const std::shared_ptr<HybridBinDataSpec>& bd);
+  void getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridRsa.cpp

@@ -0,0 +1,348 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridRsa.hpp"
+#include "HybridBinData.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 {
+
+HybridRsa::HybridRsa()
+    : HybridObject(HybridRsaSpec::TAG), ChilkatObject<CkRsa>("Rsa", CkRsa::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridRsa::HybridRsa(CkRsa* owned)
+    : HybridObject(HybridRsaSpec::TAG), ChilkatObject<CkRsa>("Rsa", owned) {
+  init();
+}
+
+void HybridRsa::init() {
+}
+
+void HybridRsa::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridRsa::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridRsa::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridRsa::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridRsa::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridRsa::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridRsa::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridRsa::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridRsa::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridRsa::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridRsa::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridRsa::getCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Charset(_s);
+  return rt::stdString(_s);
+}
+void HybridRsa::setCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "charset");
+  this->ck().put_Charset(value.c_str());
+}
+std::string HybridRsa::getEncodingMode() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_EncodingMode(_s);
+  return rt::stdString(_s);
+}
+void HybridRsa::setEncodingMode(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "encodingMode");
+  this->ck().put_EncodingMode(value.c_str());
+}
+bool HybridRsa::getLittleEndian() {
+  this->beginCall();
+  return this->ck().get_LittleEndian();
+}
+void HybridRsa::setLittleEndian(bool value) {
+  this->beginCall();
+  this->ck().put_LittleEndian(value);
+}
+bool HybridRsa::getNoUnpad() {
+  this->beginCall();
+  return this->ck().get_NoUnpad();
+}
+void HybridRsa::setNoUnpad(bool value) {
+  this->beginCall();
+  this->ck().put_NoUnpad(value);
+}
+double HybridRsa::getNumBits() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumBits());
+}
+std::string HybridRsa::getOaepHash() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OaepHash(_s);
+  return rt::stdString(_s);
+}
+void HybridRsa::setOaepHash(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oaepHash");
+  this->ck().put_OaepHash(value.c_str());
+}
+std::string HybridRsa::getOaepMgfHash() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OaepMgfHash(_s);
+  return rt::stdString(_s);
+}
+void HybridRsa::setOaepMgfHash(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oaepMgfHash");
+  this->ck().put_OaepMgfHash(value.c_str());
+}
+double HybridRsa::getPssSaltLen() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_PssSaltLen());
+}
+void HybridRsa::setPssSaltLen(double value) {
+  this->beginCall();
+  this->ck().put_PssSaltLen(rt::toInt(value, "pssSaltLen"));
+}
+std::string HybridRsa::getOaepLabel() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_OaepLabel(_s);
+  return rt::stdString(_s);
+}
+void HybridRsa::setOaepLabel(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "oaepLabel");
+  this->ck().put_OaepLabel(value.c_str());
+}
+std::string HybridRsa::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridRsa::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+bool HybridRsa::getPkcsPadding() {
+  this->beginCall();
+  return this->ck().get_PkcsPadding();
+}
+void HybridRsa::setPkcsPadding(bool value) {
+  this->beginCall();
+  this->ck().put_PkcsPadding(value);
+}
+
+// ---- Methods ----
+
+std::string HybridRsa::decryptStringENC(const std::string& str, bool usePrivateKey) {
+  this->beginCall();
+  return decryptStringENC_impl(str, usePrivateKey);
+}
+std::string HybridRsa::decryptStringENC_impl(const std::string& str, bool usePrivateKey) {
+  rt::checkNoNul(str, "str");
+  CkString _out;
+  if (!this->ck().DecryptStringENC(str.c_str(), usePrivateKey, _out)) throw this->fail("decryptStringENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridRsa::encryptStringENC(const std::string& str, bool bUsePrivateKey) {
+  this->beginCall();
+  return encryptStringENC_impl(str, bUsePrivateKey);
+}
+std::string HybridRsa::encryptStringENC_impl(const std::string& str, bool bUsePrivateKey) {
+  rt::checkNoNul(str, "str");
+  CkString _out;
+  if (!this->ck().EncryptStringENC(str.c_str(), bUsePrivateKey, _out)) throw this->fail("encryptStringENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridRsa::signHashENC(const std::string& encodedHash, const std::string& hashAlg) {
+  this->beginCall();
+  return signHashENC_impl(encodedHash, hashAlg);
+}
+std::string HybridRsa::signHashENC_impl(const std::string& encodedHash, const std::string& hashAlg) {
+  rt::checkNoNul(encodedHash, "encodedHash");
+  rt::checkNoNul(hashAlg, "hashAlg");
+  CkString _out;
+  if (!this->ck().SignHashENC(encodedHash.c_str(), hashAlg.c_str(), _out)) throw this->fail("signHashENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridRsa::signStringENC(const std::string& strToBeHashed, const std::string& hashAlgorithm) {
+  this->beginCall();
+  return signStringENC_impl(strToBeHashed, hashAlgorithm);
+}
+std::string HybridRsa::signStringENC_impl(const std::string& strToBeHashed, const std::string& hashAlgorithm) {
+  rt::checkNoNul(strToBeHashed, "strToBeHashed");
+  rt::checkNoNul(hashAlgorithm, "hashAlgorithm");
+  CkString _out;
+  if (!this->ck().SignStringENC(strToBeHashed.c_str(), hashAlgorithm.c_str(), _out)) throw this->fail("signStringENC");
+  return rt::stdString(_out);
+}
+
+std::string HybridRsa::snkToXml(const std::string& filename) {
+  this->beginCall();
+  return snkToXml_impl(filename);
+}
+std::string HybridRsa::snkToXml_impl(const std::string& filename) {
+  rt::checkNoNul(filename, "filename");
+  CkString _out;
+  if (!this->ck().SnkToXml(filename.c_str(), _out)) throw this->fail("snkToXml");
+  return rt::stdString(_out);
+}
+
+void HybridRsa::verifyHashENC(const std::string& encodedHash, const std::string& hashAlg, const std::string& encodedSig) {
+  this->beginCall();
+  verifyHashENC_impl(encodedHash, hashAlg, encodedSig);
+}
+void HybridRsa::verifyHashENC_impl(const std::string& encodedHash, const std::string& hashAlg, const std::string& encodedSig) {
+  rt::checkNoNul(encodedHash, "encodedHash");
+  rt::checkNoNul(hashAlg, "hashAlg");
+  rt::checkNoNul(encodedSig, "encodedSig");
+  if (!this->ck().VerifyHashENC(encodedHash.c_str(), hashAlg.c_str(), encodedSig.c_str())) throw this->fail("verifyHashENC");
+}
+
+void HybridRsa::verifyStringENC(const std::string& originalString, const std::string& hashAlgorithm, const std::string& encodedSig) {
+  this->beginCall();
+  verifyStringENC_impl(originalString, hashAlgorithm, encodedSig);
+}
+void HybridRsa::verifyStringENC_impl(const std::string& originalString, const std::string& hashAlgorithm, const std::string& encodedSig) {
+  rt::checkNoNul(originalString, "originalString");
+  rt::checkNoNul(hashAlgorithm, "hashAlgorithm");
+  rt::checkNoNul(encodedSig, "encodedSig");
+  if (!this->ck().VerifyStringENC(originalString.c_str(), hashAlgorithm.c_str(), encodedSig.c_str())) throw this->fail("verifyStringENC");
+}
+
+void HybridRsa::setX509Cert(const std::shared_ptr<HybridCertSpec>& cert, bool usePrivateKey) {
+  this->beginCall();
+  setX509Cert_impl(cert, usePrivateKey);
+}
+void HybridRsa::setX509Cert_impl(const std::shared_ptr<HybridCertSpec>& cert, bool usePrivateKey) {
+  if (!this->ck().SetX509Cert(rt::implOf<HybridCert>(cert, "cert").ck(), usePrivateKey)) throw this->fail("setX509Cert");
+}
+
+void HybridRsa::decryptBd(const std::shared_ptr<HybridBinDataSpec>& bd, bool usePrivateKey) {
+  this->beginCall();
+  decryptBd_impl(bd, usePrivateKey);
+}
+void HybridRsa::decryptBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, bool usePrivateKey) {
+  if (!this->ck().DecryptBd(rt::implOf<HybridBinData>(bd, "bd").ck(), usePrivateKey)) throw this->fail("decryptBd");
+}
+
+void HybridRsa::encryptBd(const std::shared_ptr<HybridBinDataSpec>& bd, bool usePrivateKey) {
+  this->beginCall();
+  encryptBd_impl(bd, usePrivateKey);
+}
+void HybridRsa::encryptBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, bool usePrivateKey) {
+  if (!this->ck().EncryptBd(rt::implOf<HybridBinData>(bd, "bd").ck(), usePrivateKey)) throw this->fail("encryptBd");
+}
+
+void HybridRsa::signBd(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlgorithm, const std::shared_ptr<HybridBinDataSpec>& bdSig) {
+  this->beginCall();
+  signBd_impl(bdData, hashAlgorithm, bdSig);
+}
+void HybridRsa::signBd_impl(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlgorithm, const std::shared_ptr<HybridBinDataSpec>& bdSig) {
+  rt::checkNoNul(hashAlgorithm, "hashAlgorithm");
+  if (!this->ck().SignBd(rt::implOf<HybridBinData>(bdData, "bdData").ck(), hashAlgorithm.c_str(), rt::implOf<HybridBinData>(bdSig, "bdSig").ck())) throw this->fail("signBd");
+}
+
+void HybridRsa::verifyBd(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlgorithm, const std::shared_ptr<HybridBinDataSpec>& bdSig) {
+  this->beginCall();
+  verifyBd_impl(bdData, hashAlgorithm, bdSig);
+}
+void HybridRsa::verifyBd_impl(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlgorithm, const std::shared_ptr<HybridBinDataSpec>& bdSig) {
+  rt::checkNoNul(hashAlgorithm, "hashAlgorithm");
+  if (!this->ck().VerifyBd(rt::implOf<HybridBinData>(bdData, "bdData").ck(), hashAlgorithm.c_str(), rt::implOf<HybridBinData>(bdSig, "bdSig").ck())) throw this->fail("verifyBd");
+}
+
+void HybridRsa::genKey(double numBits, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  genKey_impl(numBits, privKey);
+}
+void HybridRsa::genKey_impl(double numBits, const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  if (!this->ck().GenKey(rt::toInt(numBits, "numBits"), rt::implOf<HybridPrivateKey>(privKey, "privKey").ck())) throw this->fail("genKey");
+}
+
+void HybridRsa::usePrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  this->beginCall();
+  usePrivateKey_impl(privKey);
+}
+void HybridRsa::usePrivateKey_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey) {
+  if (!this->ck().UsePrivateKey(rt::implOf<HybridPrivateKey>(privKey, "privKey").ck())) throw this->fail("usePrivateKey");
+}
+
+void HybridRsa::usePublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubKey) {
+  this->beginCall();
+  usePublicKey_impl(pubKey);
+}
+void HybridRsa::usePublicKey_impl(const std::shared_ptr<HybridPublicKeySpec>& pubKey) {
+  if (!this->ck().UsePublicKey(rt::implOf<HybridPublicKey>(pubKey, "pubKey").ck())) throw this->fail("usePublicKey");
+}
+
+void HybridRsa::signRawBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  signRawBd_impl(bd);
+}
+void HybridRsa::signRawBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().SignRawBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("signRawBd");
+}
+
+void HybridRsa::verifyRawBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  verifyRawBd_impl(bd);
+}
+void HybridRsa::verifyRawBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().VerifyRawBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("verifyRawBd");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridRsa.hpp

@@ -0,0 +1,90 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Rsa: the Nitro HybridObject over Chilkat's CkRsa (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridRsaSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkRsa.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridRsa final : public HybridRsaSpec, public ChilkatObject<CkRsa> {
+public:
+  HybridRsa();                                  // `new Rsa()` from JS
+  explicit HybridRsa(CkRsa* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  std::string getCharset() override;
+  void setCharset(const std::string& value) override;
+  std::string getEncodingMode() override;
+  void setEncodingMode(const std::string& value) override;
+  bool getLittleEndian() override;
+  void setLittleEndian(bool value) override;
+  bool getNoUnpad() override;
+  void setNoUnpad(bool value) override;
+  double getNumBits() override;
+  std::string getOaepHash() override;
+  void setOaepHash(const std::string& value) override;
+  std::string getOaepMgfHash() override;
+  void setOaepMgfHash(const std::string& value) override;
+  double getPssSaltLen() override;
+  void setPssSaltLen(double value) override;
+  std::string getOaepLabel() override;
+  void setOaepLabel(const std::string& value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+  bool getPkcsPadding() override;
+  void setPkcsPadding(bool value) override;
+
+  // ---- Methods ----
+  std::string decryptStringENC(const std::string& str, bool usePrivateKey) override;
+  std::string encryptStringENC(const std::string& str, bool bUsePrivateKey) override;
+  std::string signHashENC(const std::string& encodedHash, const std::string& hashAlg) override;
+  std::string signStringENC(const std::string& strToBeHashed, const std::string& hashAlgorithm) override;
+  std::string snkToXml(const std::string& filename) override;
+  void verifyHashENC(const std::string& encodedHash, const std::string& hashAlg, const std::string& encodedSig) override;
+  void verifyStringENC(const std::string& originalString, const std::string& hashAlgorithm, const std::string& encodedSig) override;
+  void setX509Cert(const std::shared_ptr<HybridCertSpec>& cert, bool usePrivateKey) override;
+  void decryptBd(const std::shared_ptr<HybridBinDataSpec>& bd, bool usePrivateKey) override;
+  void encryptBd(const std::shared_ptr<HybridBinDataSpec>& bd, bool usePrivateKey) override;
+  void signBd(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlgorithm, const std::shared_ptr<HybridBinDataSpec>& bdSig) override;
+  void verifyBd(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlgorithm, const std::shared_ptr<HybridBinDataSpec>& bdSig) override;
+  void genKey(double numBits, const std::shared_ptr<HybridPrivateKeySpec>& privKey) override;
+  void usePrivateKey(const std::shared_ptr<HybridPrivateKeySpec>& privKey) override;
+  void usePublicKey(const std::shared_ptr<HybridPublicKeySpec>& pubKey) override;
+  void signRawBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void verifyRawBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+
+private:
+  void init();
+  std::string decryptStringENC_impl(const std::string& str, bool usePrivateKey);
+  std::string encryptStringENC_impl(const std::string& str, bool bUsePrivateKey);
+  std::string signHashENC_impl(const std::string& encodedHash, const std::string& hashAlg);
+  std::string signStringENC_impl(const std::string& strToBeHashed, const std::string& hashAlgorithm);
+  std::string snkToXml_impl(const std::string& filename);
+  void verifyHashENC_impl(const std::string& encodedHash, const std::string& hashAlg, const std::string& encodedSig);
+  void verifyStringENC_impl(const std::string& originalString, const std::string& hashAlgorithm, const std::string& encodedSig);
+  void setX509Cert_impl(const std::shared_ptr<HybridCertSpec>& cert, bool usePrivateKey);
+  void decryptBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, bool usePrivateKey);
+  void encryptBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, bool usePrivateKey);
+  void signBd_impl(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlgorithm, const std::shared_ptr<HybridBinDataSpec>& bdSig);
+  void verifyBd_impl(const std::shared_ptr<HybridBinDataSpec>& bdData, const std::string& hashAlgorithm, const std::shared_ptr<HybridBinDataSpec>& bdSig);
+  void genKey_impl(double numBits, const std::shared_ptr<HybridPrivateKeySpec>& privKey);
+  void usePrivateKey_impl(const std::shared_ptr<HybridPrivateKeySpec>& privKey);
+  void usePublicKey_impl(const std::shared_ptr<HybridPublicKeySpec>& pubKey);
+  void signRawBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  void verifyRawBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+};
+
+} // namespace margelo::nitro::chilkat