@chilkat/react-native 11.6.1

package/cpp/HybridSecrets.cpp

@@ -0,0 +1,328 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridSecrets.hpp"
+#include "HybridBinData.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 {
+
+HybridSecrets::HybridSecrets()
+    : HybridObject(HybridSecretsSpec::TAG), ChilkatObject<CkSecrets>("Secrets", CkSecrets::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridSecrets::HybridSecrets(CkSecrets* owned)
+    : HybridObject(HybridSecretsSpec::TAG), ChilkatObject<CkSecrets>("Secrets", owned) {
+  init();
+}
+
+void HybridSecrets::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridSecrets::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridSecrets::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSecrets::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSecrets::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSecrets::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSecrets::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridSecrets::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridSecrets::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridSecrets::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridSecrets::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridSecrets::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridSecrets::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridSecrets::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+std::string HybridSecrets::getLocation() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Location(_s);
+  return rt::stdString(_s);
+}
+void HybridSecrets::setLocation(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "location");
+  this->ck().put_Location(value.c_str());
+}
+bool HybridSecrets::getCompression() {
+  this->beginCall();
+  return this->ck().get_Compression();
+}
+void HybridSecrets::setCompression(bool value) {
+  this->beginCall();
+  this->ck().put_Compression(value);
+}
+bool HybridSecrets::getAutoSplit() {
+  this->beginCall();
+  return this->ck().get_AutoSplit();
+}
+void HybridSecrets::setAutoSplit(bool value) {
+  this->beginCall();
+  this->ck().put_AutoSplit(value);
+}
+
+// ---- Methods ----
+
+std::string HybridSecrets::getSecretStr(const std::shared_ptr<HybridJsonObjectSpec>& jsonId) {
+  this->beginCall();
+  return getSecretStr_impl(jsonId);
+}
+std::string HybridSecrets::getSecretStr_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId) {
+  CkString _out;
+  if (!this->ck().GetSecretStr(rt::implOf<HybridJsonObject>(jsonId, "jsonId").ck(), _out)) throw this->fail("getSecretStr");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSecrets::getSecretStrAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSecrets>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(jsonId);
+  return rt::runAsync<std::string>("Secrets.getSecretStrAsync", std::move(_parts), [_self, jsonId]() {
+    return _self->getSecretStr_impl(jsonId);
+  });
+}
+
+void HybridSecrets::getSecretBd(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  getSecretBd_impl(jsonId, bd);
+}
+void HybridSecrets::getSecretBd_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().GetSecretBd(rt::implOf<HybridJsonObject>(jsonId, "jsonId").ck(), rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("getSecretBd");
+}
+std::shared_ptr<Promise<void>> HybridSecrets::getSecretBdAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSecrets>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(jsonId);
+  _parts.push_back(bd);
+  return rt::runAsync<void>("Secrets.getSecretBdAsync", std::move(_parts), [_self, jsonId, bd]() {
+    _self->getSecretBd_impl(jsonId, bd);
+  });
+}
+
+void HybridSecrets::getSecretJson(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) {
+  this->beginCall();
+  getSecretJson_impl(jsonId, jsonOut);
+}
+void HybridSecrets::getSecretJson_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) {
+  if (!this->ck().GetSecretJson(rt::implOf<HybridJsonObject>(jsonId, "jsonId").ck(), rt::implOf<HybridJsonObject>(jsonOut, "jsonOut").ck())) throw this->fail("getSecretJson");
+}
+std::shared_ptr<Promise<void>> HybridSecrets::getSecretJsonAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSecrets>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(jsonId);
+  _parts.push_back(jsonOut);
+  return rt::runAsync<void>("Secrets.getSecretJsonAsync", std::move(_parts), [_self, jsonId, jsonOut]() {
+    _self->getSecretJson_impl(jsonId, jsonOut);
+  });
+}
+
+void HybridSecrets::updateSecretStr(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::string& secret) {
+  this->beginCall();
+  updateSecretStr_impl(jsonId, secret);
+}
+void HybridSecrets::updateSecretStr_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::string& secret) {
+  rt::checkNoNul(secret, "secret");
+  if (!this->ck().UpdateSecretStr(rt::implOf<HybridJsonObject>(jsonId, "jsonId").ck(), secret.c_str())) throw this->fail("updateSecretStr");
+}
+std::shared_ptr<Promise<void>> HybridSecrets::updateSecretStrAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::string& secret) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSecrets>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(jsonId);
+  return rt::runAsync<void>("Secrets.updateSecretStrAsync", std::move(_parts), [_self, jsonId, secret]() {
+    _self->updateSecretStr_impl(jsonId, secret);
+  });
+}
+
+void HybridSecrets::updateSecretJson(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridJsonObjectSpec>& secret) {
+  this->beginCall();
+  updateSecretJson_impl(jsonId, secret);
+}
+void HybridSecrets::updateSecretJson_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridJsonObjectSpec>& secret) {
+  if (!this->ck().UpdateSecretJson(rt::implOf<HybridJsonObject>(jsonId, "jsonId").ck(), rt::implOf<HybridJsonObject>(secret, "secret").ck())) throw this->fail("updateSecretJson");
+}
+std::shared_ptr<Promise<void>> HybridSecrets::updateSecretJsonAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridJsonObjectSpec>& secret) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSecrets>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(jsonId);
+  _parts.push_back(secret);
+  return rt::runAsync<void>("Secrets.updateSecretJsonAsync", std::move(_parts), [_self, jsonId, secret]() {
+    _self->updateSecretJson_impl(jsonId, secret);
+  });
+}
+
+void HybridSecrets::updateSecretBd(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridBinDataSpec>& secret) {
+  this->beginCall();
+  updateSecretBd_impl(jsonId, secret);
+}
+void HybridSecrets::updateSecretBd_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridBinDataSpec>& secret) {
+  if (!this->ck().UpdateSecretBd(rt::implOf<HybridJsonObject>(jsonId, "jsonId").ck(), rt::implOf<HybridBinData>(secret, "secret").ck())) throw this->fail("updateSecretBd");
+}
+std::shared_ptr<Promise<void>> HybridSecrets::updateSecretBdAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridBinDataSpec>& secret) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSecrets>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(jsonId);
+  _parts.push_back(secret);
+  return rt::runAsync<void>("Secrets.updateSecretBdAsync", std::move(_parts), [_self, jsonId, secret]() {
+    _self->updateSecretBd_impl(jsonId, secret);
+  });
+}
+
+void HybridSecrets::deleteSecret(const std::shared_ptr<HybridJsonObjectSpec>& jsonId) {
+  this->beginCall();
+  deleteSecret_impl(jsonId);
+}
+void HybridSecrets::deleteSecret_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId) {
+  if (!this->ck().DeleteSecret(rt::implOf<HybridJsonObject>(jsonId, "jsonId").ck())) throw this->fail("deleteSecret");
+}
+std::shared_ptr<Promise<void>> HybridSecrets::deleteSecretAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSecrets>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(jsonId);
+  return rt::runAsync<void>("Secrets.deleteSecretAsync", std::move(_parts), [_self, jsonId]() {
+    _self->deleteSecret_impl(jsonId);
+  });
+}
+
+void HybridSecrets::listSecrets(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) {
+  this->beginCall();
+  listSecrets_impl(json, jsonOut);
+}
+void HybridSecrets::listSecrets_impl(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) {
+  if (!this->ck().ListSecrets(rt::implOf<HybridJsonObject>(json, "json").ck(), rt::implOf<HybridJsonObject>(jsonOut, "jsonOut").ck())) throw this->fail("listSecrets");
+}
+std::shared_ptr<Promise<void>> HybridSecrets::listSecretsAsync(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSecrets>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(json);
+  _parts.push_back(jsonOut);
+  return rt::runAsync<void>("Secrets.listSecretsAsync", std::move(_parts), [_self, json, jsonOut]() {
+    _self->listSecrets_impl(json, jsonOut);
+  });
+}
+
+void HybridSecrets::setBootstrapSecret(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridSecretsSpec>& secretContent) {
+  this->beginCall();
+  setBootstrapSecret_impl(jsonId, secretContent);
+}
+void HybridSecrets::setBootstrapSecret_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridSecretsSpec>& secretContent) {
+  if (!this->ck().SetBootstrapSecret(rt::implOf<HybridJsonObject>(jsonId, "jsonId").ck(), rt::implOf<HybridSecrets>(secretContent, "secretContent").ck())) throw this->fail("setBootstrapSecret");
+}
+
+void HybridSecrets::getSecretSb(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  getSecretSb_impl(jsonId, sb);
+}
+void HybridSecrets::getSecretSb_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().GetSecretSb(rt::implOf<HybridJsonObject>(jsonId, "jsonId").ck(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("getSecretSb");
+}
+std::shared_ptr<Promise<void>> HybridSecrets::getSecretSbAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSecrets>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(jsonId);
+  _parts.push_back(sb);
+  return rt::runAsync<void>("Secrets.getSecretSbAsync", std::move(_parts), [_self, jsonId, sb]() {
+    _self->getSecretSb_impl(jsonId, sb);
+  });
+}
+
+void HybridSecrets::updateSecretSb(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  updateSecretSb_impl(jsonId, sb);
+}
+void HybridSecrets::updateSecretSb_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().UpdateSecretSb(rt::implOf<HybridJsonObject>(jsonId, "jsonId").ck(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("updateSecretSb");
+}
+std::shared_ptr<Promise<void>> HybridSecrets::updateSecretSbAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSecrets>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(jsonId);
+  _parts.push_back(sb);
+  return rt::runAsync<void>("Secrets.updateSecretSbAsync", std::move(_parts), [_self, jsonId, sb]() {
+    _self->updateSecretSb_impl(jsonId, sb);
+  });
+}
+
+void HybridSecrets::secretSpecToJson(const std::string& secretSpec, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  secretSpecToJson_impl(secretSpec, json);
+}
+void HybridSecrets::secretSpecToJson_impl(const std::string& secretSpec, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  rt::checkNoNul(secretSpec, "secretSpec");
+  if (!this->ck().SecretSpecToJson(secretSpec.c_str(), rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("secretSpecToJson");
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridSecrets::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridSecrets::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridSecrets::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridSecrets::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridSecrets::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridSecrets.hpp

@@ -0,0 +1,84 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Secrets: the Nitro HybridObject over Chilkat's CkSecrets (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridSecretsSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkSecrets.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridSecrets final : public HybridSecretsSpec, public ChilkatObject<CkSecrets> {
+public:
+  HybridSecrets();                                  // `new Secrets()` from JS
+  explicit HybridSecrets(CkSecrets* 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 getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+  std::string getLocation() override;
+  void setLocation(const std::string& value) override;
+  bool getCompression() override;
+  void setCompression(bool value) override;
+  bool getAutoSplit() override;
+  void setAutoSplit(bool value) override;
+
+  // ---- Methods ----
+  std::string getSecretStr(const std::shared_ptr<HybridJsonObjectSpec>& jsonId) override;
+  std::shared_ptr<Promise<std::string>> getSecretStrAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId) override;
+  void getSecretBd(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  std::shared_ptr<Promise<void>> getSecretBdAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void getSecretJson(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  std::shared_ptr<Promise<void>> getSecretJsonAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  void updateSecretStr(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::string& secret) override;
+  std::shared_ptr<Promise<void>> updateSecretStrAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::string& secret) override;
+  void updateSecretJson(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridJsonObjectSpec>& secret) override;
+  std::shared_ptr<Promise<void>> updateSecretJsonAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridJsonObjectSpec>& secret) override;
+  void updateSecretBd(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridBinDataSpec>& secret) override;
+  std::shared_ptr<Promise<void>> updateSecretBdAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridBinDataSpec>& secret) override;
+  void deleteSecret(const std::shared_ptr<HybridJsonObjectSpec>& jsonId) override;
+  std::shared_ptr<Promise<void>> deleteSecretAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId) override;
+  void listSecrets(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  std::shared_ptr<Promise<void>> listSecretsAsync(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut) override;
+  void setBootstrapSecret(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridSecretsSpec>& secretContent) override;
+  void getSecretSb(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  std::shared_ptr<Promise<void>> getSecretSbAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void updateSecretSb(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  std::shared_ptr<Promise<void>> updateSecretSbAsync(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void secretSpecToJson(const std::string& secretSpec, 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();
+  std::string getSecretStr_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId);
+  void getSecretBd_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridBinDataSpec>& bd);
+  void getSecretJson_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut);
+  void updateSecretStr_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::string& secret);
+  void updateSecretJson_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridJsonObjectSpec>& secret);
+  void updateSecretBd_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridBinDataSpec>& secret);
+  void deleteSecret_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId);
+  void listSecrets_impl(const std::shared_ptr<HybridJsonObjectSpec>& json, const std::shared_ptr<HybridJsonObjectSpec>& jsonOut);
+  void setBootstrapSecret_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridSecretsSpec>& secretContent);
+  void getSecretSb_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void updateSecretSb_impl(const std::shared_ptr<HybridJsonObjectSpec>& jsonId, const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void secretSpecToJson_impl(const std::string& secretSpec, const std::shared_ptr<HybridJsonObjectSpec>& json);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridSecureString.cpp

@@ -0,0 +1,175 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridSecureString.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridSecureString::HybridSecureString()
+    : HybridObject(HybridSecureStringSpec::TAG), ChilkatObject<CkSecureString>("SecureString", CkSecureString::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridSecureString::HybridSecureString(CkSecureString* owned)
+    : HybridObject(HybridSecureStringSpec::TAG), ChilkatObject<CkSecureString>("SecureString", owned) {
+  init();
+}
+
+void HybridSecureString::init() {
+}
+
+void HybridSecureString::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridSecureString::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSecureString::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSecureString::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSecureString::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSecureString::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridSecureString::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridSecureString::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridSecureString::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridSecureString::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridSecureString::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridSecureString::getMaintainHash() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_MaintainHash(_s);
+  return rt::stdString(_s);
+}
+void HybridSecureString::setMaintainHash(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "maintainHash");
+  this->ck().put_MaintainHash(value.c_str());
+}
+bool HybridSecureString::getReadOnly() {
+  this->beginCall();
+  return this->ck().get_ReadOnly();
+}
+void HybridSecureString::setReadOnly(bool value) {
+  this->beginCall();
+  this->ck().put_ReadOnly(value);
+}
+
+// ---- Methods ----
+
+std::string HybridSecureString::access() {
+  this->beginCall();
+  return access_impl();
+}
+std::string HybridSecureString::access_impl() {
+  CkString _out;
+  if (!this->ck().Access(_out)) throw this->fail("access");
+  return rt::stdString(_out);
+}
+
+void HybridSecureString::append(const std::string& str) {
+  this->beginCall();
+  append_impl(str);
+}
+void HybridSecureString::append_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  if (!this->ck().Append(str.c_str())) throw this->fail("append");
+}
+
+void HybridSecureString::appendSecure(const std::shared_ptr<HybridSecureStringSpec>& secStr) {
+  this->beginCall();
+  appendSecure_impl(secStr);
+}
+void HybridSecureString::appendSecure_impl(const std::shared_ptr<HybridSecureStringSpec>& secStr) {
+  if (!this->ck().AppendSecure(rt::implOf<HybridSecureString>(secStr, "secStr").ck())) throw this->fail("appendSecure");
+}
+
+void HybridSecureString::verifyHash(const std::string& hashVal, const std::string& encoding) {
+  this->beginCall();
+  verifyHash_impl(hashVal, encoding);
+}
+void HybridSecureString::verifyHash_impl(const std::string& hashVal, const std::string& encoding) {
+  rt::checkNoNul(hashVal, "hashVal");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().VerifyHash(hashVal.c_str(), encoding.c_str())) throw this->fail("verifyHash");
+}
+
+void HybridSecureString::secStrEquals(const std::shared_ptr<HybridSecureStringSpec>& secStr) {
+  this->beginCall();
+  secStrEquals_impl(secStr);
+}
+void HybridSecureString::secStrEquals_impl(const std::shared_ptr<HybridSecureStringSpec>& secStr) {
+  if (!this->ck().SecStrEquals(rt::implOf<HybridSecureString>(secStr, "secStr").ck())) throw this->fail("secStrEquals");
+}
+
+std::string HybridSecureString::hashVal(const std::string& encoding) {
+  this->beginCall();
+  return hashVal_impl(encoding);
+}
+std::string HybridSecureString::hashVal_impl(const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().HashVal(encoding.c_str(), _out)) throw this->fail("hashVal");
+  return rt::stdString(_out);
+}
+
+void HybridSecureString::appendSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  appendSb_impl(sb);
+}
+void HybridSecureString::appendSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  if (!this->ck().AppendSb(rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("appendSb");
+}
+
+void HybridSecureString::loadFile(const std::string& path, const std::string& charset) {
+  this->beginCall();
+  loadFile_impl(path, charset);
+}
+void HybridSecureString::loadFile_impl(const std::string& path, const std::string& charset) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().LoadFile(path.c_str(), charset.c_str())) throw this->fail("loadFile");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridSecureString.hpp

@@ -0,0 +1,55 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// SecureString: the Nitro HybridObject over Chilkat's CkSecureString (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridSecureStringSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkSecureString.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridSecureString final : public HybridSecureStringSpec, public ChilkatObject<CkSecureString> {
+public:
+  HybridSecureString();                                  // `new SecureString()` from JS
+  explicit HybridSecureString(CkSecureString* 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 getMaintainHash() override;
+  void setMaintainHash(const std::string& value) override;
+  bool getReadOnly() override;
+  void setReadOnly(bool value) override;
+
+  // ---- Methods ----
+  std::string access() override;
+  void append(const std::string& str) override;
+  void appendSecure(const std::shared_ptr<HybridSecureStringSpec>& secStr) override;
+  void verifyHash(const std::string& hashVal, const std::string& encoding) override;
+  void secStrEquals(const std::shared_ptr<HybridSecureStringSpec>& secStr) override;
+  std::string hashVal(const std::string& encoding) override;
+  void appendSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void loadFile(const std::string& path, const std::string& charset) override;
+
+private:
+  void init();
+  std::string access_impl();
+  void append_impl(const std::string& str);
+  void appendSecure_impl(const std::shared_ptr<HybridSecureStringSpec>& secStr);
+  void verifyHash_impl(const std::string& hashVal, const std::string& encoding);
+  void secStrEquals_impl(const std::shared_ptr<HybridSecureStringSpec>& secStr);
+  std::string hashVal_impl(const std::string& encoding);
+  void appendSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void loadFile_impl(const std::string& path, const std::string& charset);
+};
+
+} // namespace margelo::nitro::chilkat