@chilkat/react-native 11.6.1

package/cpp/HybridAi.hpp

@@ -0,0 +1,159 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Ai: the Nitro HybridObject over Chilkat's CkAi (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridAiSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkAi.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridAi final : public HybridAiSpec, public ChilkatObject<CkAi> {
+public:
+  HybridAi();                                  // `new Ai()` from JS
+  explicit HybridAi(CkAi* 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 getProvider() override;
+  void setProvider(const std::string& value) override;
+  std::string getSelectedConvo() override;
+  void setSelectedConvo(const std::string& value) override;
+  std::string getApiKey() override;
+  void setApiKey(const std::string& value) override;
+  std::string getModel() override;
+  void setModel(const std::string& value) override;
+  bool getFullTranscript() override;
+  void setFullTranscript(bool value) override;
+  bool getStreaming() override;
+  void setStreaming(bool value) override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+  bool getHostedConvo() override;
+  void setHostedConvo(bool value) override;
+  std::string getUncommonOptions() override;
+  void setUncommonOptions(const std::string& value) override;
+  double getIdleTimeoutMs() override;
+  void setIdleTimeoutMs(double value) override;
+  double getResponseStatusCode() override;
+  std::string getApiSpec() override;
+  void setApiSpec(const std::string& value) override;
+  std::string getBaseUrl() override;
+  void setBaseUrl(const std::string& value) override;
+  std::string getApiKeyHeader() override;
+  void setApiKeyHeader(const std::string& value) override;
+  bool getHasFunctionCalls() override;
+  double getJsToolTimeout() override;
+  void setJsToolTimeout(double value) override;
+  bool getEnableSecrets() override;
+  void setEnableSecrets(bool value) override;
+  bool getLastResponseRefused() override;
+  std::string getRefusalText() override;
+
+  // ---- Methods ----
+  void newConvo(const std::string& name, const std::string& sysMsg, const std::string& devMsg) override;
+  void exportConvo(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void importConvo(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void listConvos(const std::shared_ptr<HybridStringTableSpec>& st) override;
+  void deleteConvo(const std::string& name) override;
+  void setConnectionSettings(const std::shared_ptr<HybridSocketSpec>& sock) override;
+  void ask(const std::string& outputType) override;
+  std::shared_ptr<Promise<void>> askAsync(const std::string& outputType) override;
+  void getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void getModels(const std::shared_ptr<HybridStringTableSpec>& st) override;
+  std::shared_ptr<Promise<void>> getModelsAsync(const std::shared_ptr<HybridStringTableSpec>& st) override;
+  void inputAddText(const std::string& text) override;
+  std::string getOutputText() override;
+  void getOutputTextSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void inputClear() override;
+  void inputAddTextSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void inputAddImageData(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& summary) override;
+  void inputAddImageUrl(const std::string& url, const std::string& summary) override;
+  void inputAddFileData(const std::string& filename, const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& summary) override;
+  void inputAddFileUrl(const std::string& url, const std::string& summary) override;
+  double pollAi(bool abort) override;
+  void nextAiEvent(double maxWaitMs, const std::shared_ptr<HybridStringBuilderSpec>& sbName, const std::shared_ptr<HybridStringBuilderSpec>& sbDelta) override;
+  void sleepMs(double millisec) override;
+  void setProviderParams(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void setAskParams(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void registerManualTools(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void getFunctionCalls(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void getSearchResults(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void useMcp(const std::shared_ptr<HybridMcpSpec>& cMcp, const std::string& namePrefix) override;
+  std::shared_ptr<Promise<void>> useMcpAsync(const std::shared_ptr<HybridMcpSpec>& cMcp, const std::string& namePrefix) override;
+  void setOutputSchema(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& schema, bool strict) override;
+  void getOutputJson(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void inputAddFnResult(const std::string& callId, const std::string& fnResult) override;
+  void registerJsTools(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool evalOnly, bool allowAllKeyword) override;
+  void streamingJsToolCall(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  std::shared_ptr<Promise<void>> streamingJsToolCallAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb) override;
+  void inputAddFileId(const std::string& fileId, const std::string& mimeType) override;
+  void getOutputBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  std::string uploadFile(const std::string& path, const std::string& mimeType) override;
+  std::shared_ptr<Promise<std::string>> uploadFileAsync(const std::string& path, const std::string& mimeType) override;
+  std::string uploadFileBd(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filename, const std::string& mimeType) override;
+  std::shared_ptr<Promise<std::string>> uploadFileBdAsync(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filename, const std::string& mimeType) override;
+  std::string uploadFileSb(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& filename, const std::string& mimeType) override;
+  std::shared_ptr<Promise<std::string>> uploadFileSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& filename, const std::string& mimeType) override;
+  void inputAddImageFileId(const std::string& fileId, const std::string& mimeType) 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 newConvo_impl(const std::string& name, const std::string& sysMsg, const std::string& devMsg);
+  void exportConvo_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void importConvo_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void listConvos_impl(const std::shared_ptr<HybridStringTableSpec>& st);
+  void deleteConvo_impl(const std::string& name);
+  void setConnectionSettings_impl(const std::shared_ptr<HybridSocketSpec>& sock);
+  void ask_impl(const std::string& outputType);
+  void getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void getModels_impl(const std::shared_ptr<HybridStringTableSpec>& st);
+  void inputAddText_impl(const std::string& text);
+  std::string getOutputText_impl();
+  void getOutputTextSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void inputClear_impl();
+  void inputAddTextSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void inputAddImageData_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& summary);
+  void inputAddImageUrl_impl(const std::string& url, const std::string& summary);
+  void inputAddFileData_impl(const std::string& filename, const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& summary);
+  void inputAddFileUrl_impl(const std::string& url, const std::string& summary);
+  double pollAi_impl(bool abort);
+  void nextAiEvent_impl(double maxWaitMs, const std::shared_ptr<HybridStringBuilderSpec>& sbName, const std::shared_ptr<HybridStringBuilderSpec>& sbDelta);
+  void sleepMs_impl(double millisec);
+  void setProviderParams_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void setAskParams_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void registerManualTools_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void getFunctionCalls_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void getSearchResults_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void useMcp_impl(const std::shared_ptr<HybridMcpSpec>& cMcp, const std::string& namePrefix);
+  void setOutputSchema_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& schema, bool strict);
+  void getOutputJson_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void inputAddFnResult_impl(const std::string& callId, const std::string& fnResult);
+  void registerJsTools_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, bool evalOnly, bool allowAllKeyword);
+  void streamingJsToolCall_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb);
+  void inputAddFileId_impl(const std::string& fileId, const std::string& mimeType);
+  void getOutputBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  std::string uploadFile_impl(const std::string& path, const std::string& mimeType);
+  std::string uploadFileBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd, const std::string& filename, const std::string& mimeType);
+  std::string uploadFileSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& sb, const std::string& filename, const std::string& mimeType);
+  void inputAddImageFileId_impl(const std::string& fileId, const std::string& mimeType);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridAsn.cpp

@@ -0,0 +1,403 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridAsn.hpp"
+#include "HybridBinData.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridAsn::HybridAsn()
+    : HybridObject(HybridAsnSpec::TAG), ChilkatObject<CkAsn>("Asn", CkAsn::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridAsn::HybridAsn(CkAsn* owned)
+    : HybridObject(HybridAsnSpec::TAG), ChilkatObject<CkAsn>("Asn", owned) {
+  init();
+}
+
+void HybridAsn::init() {
+}
+
+void HybridAsn::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridAsn::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridAsn::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridAsn::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridAsn::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridAsn::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridAsn::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridAsn::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridAsn::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridAsn::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridAsn::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridAsn::getBoolValue() {
+  this->beginCall();
+  return this->ck().get_BoolValue();
+}
+void HybridAsn::setBoolValue(bool value) {
+  this->beginCall();
+  this->ck().put_BoolValue(value);
+}
+bool HybridAsn::getConstructed() {
+  this->beginCall();
+  return this->ck().get_Constructed();
+}
+std::string HybridAsn::getContentStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ContentStr(_s);
+  return rt::stdString(_s);
+}
+void HybridAsn::setContentStr(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "contentStr");
+  this->ck().put_ContentStr(value.c_str());
+}
+double HybridAsn::getIntValue() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_IntValue());
+}
+void HybridAsn::setIntValue(double value) {
+  this->beginCall();
+  this->ck().put_IntValue(rt::toInt(value, "intValue"));
+}
+double HybridAsn::getNumSubItems() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumSubItems());
+}
+std::string HybridAsn::getTag() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Tag(_s);
+  return rt::stdString(_s);
+}
+double HybridAsn::getTagValue() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_TagValue());
+}
+
+// ---- Methods ----
+
+void HybridAsn::appendBigInt(const std::string& encodedBytes, const std::string& encoding) {
+  this->beginCall();
+  appendBigInt_impl(encodedBytes, encoding);
+}
+void HybridAsn::appendBigInt_impl(const std::string& encodedBytes, const std::string& encoding) {
+  rt::checkNoNul(encodedBytes, "encodedBytes");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().AppendBigInt(encodedBytes.c_str(), encoding.c_str())) throw this->fail("appendBigInt");
+}
+
+void HybridAsn::appendBits(const std::string& encodedBytes, const std::string& encoding) {
+  this->beginCall();
+  appendBits_impl(encodedBytes, encoding);
+}
+void HybridAsn::appendBits_impl(const std::string& encodedBytes, const std::string& encoding) {
+  rt::checkNoNul(encodedBytes, "encodedBytes");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().AppendBits(encodedBytes.c_str(), encoding.c_str())) throw this->fail("appendBits");
+}
+
+void HybridAsn::appendBool(bool value) {
+  this->beginCall();
+  appendBool_impl(value);
+}
+void HybridAsn::appendBool_impl(bool value) {
+  if (!this->ck().AppendBool(value)) throw this->fail("appendBool");
+}
+
+void HybridAsn::appendContextConstructed(double tag) {
+  this->beginCall();
+  appendContextConstructed_impl(tag);
+}
+void HybridAsn::appendContextConstructed_impl(double tag) {
+  if (!this->ck().AppendContextConstructed(rt::toInt(tag, "tag"))) throw this->fail("appendContextConstructed");
+}
+
+void HybridAsn::appendContextPrimitive(double tag, const std::string& encodedBytes, const std::string& encoding) {
+  this->beginCall();
+  appendContextPrimitive_impl(tag, encodedBytes, encoding);
+}
+void HybridAsn::appendContextPrimitive_impl(double tag, const std::string& encodedBytes, const std::string& encoding) {
+  rt::checkNoNul(encodedBytes, "encodedBytes");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().AppendContextPrimitive(rt::toInt(tag, "tag"), encodedBytes.c_str(), encoding.c_str())) throw this->fail("appendContextPrimitive");
+}
+
+void HybridAsn::appendInt(double value) {
+  this->beginCall();
+  appendInt_impl(value);
+}
+void HybridAsn::appendInt_impl(double value) {
+  if (!this->ck().AppendInt(rt::toInt(value, "value"))) throw this->fail("appendInt");
+}
+
+void HybridAsn::appendNull() {
+  this->beginCall();
+  appendNull_impl();
+}
+void HybridAsn::appendNull_impl() {
+  if (!this->ck().AppendNull()) throw this->fail("appendNull");
+}
+
+void HybridAsn::appendOctets(const std::string& encodedBytes, const std::string& encoding) {
+  this->beginCall();
+  appendOctets_impl(encodedBytes, encoding);
+}
+void HybridAsn::appendOctets_impl(const std::string& encodedBytes, const std::string& encoding) {
+  rt::checkNoNul(encodedBytes, "encodedBytes");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().AppendOctets(encodedBytes.c_str(), encoding.c_str())) throw this->fail("appendOctets");
+}
+
+void HybridAsn::appendOid(const std::string& oid) {
+  this->beginCall();
+  appendOid_impl(oid);
+}
+void HybridAsn::appendOid_impl(const std::string& oid) {
+  rt::checkNoNul(oid, "oid");
+  if (!this->ck().AppendOid(oid.c_str())) throw this->fail("appendOid");
+}
+
+void HybridAsn::appendSequence() {
+  this->beginCall();
+  appendSequence_impl();
+}
+void HybridAsn::appendSequence_impl() {
+  if (!this->ck().AppendSequence()) throw this->fail("appendSequence");
+}
+
+void HybridAsn::appendSequence2() {
+  this->beginCall();
+  appendSequence2_impl();
+}
+void HybridAsn::appendSequence2_impl() {
+  if (!this->ck().AppendSequence2()) throw this->fail("appendSequence2");
+}
+
+std::shared_ptr<HybridAsnSpec> HybridAsn::appendSequenceR() {
+  this->beginCall();
+  return appendSequenceR_impl();
+}
+std::shared_ptr<HybridAsnSpec> HybridAsn::appendSequenceR_impl() {
+  CkAsn* _r = this->ck().AppendSequenceR();
+  if (!_r) throw this->fail("appendSequenceR");
+  return std::make_shared<HybridAsn>(_r);
+}
+
+void HybridAsn::appendSet() {
+  this->beginCall();
+  appendSet_impl();
+}
+void HybridAsn::appendSet_impl() {
+  if (!this->ck().AppendSet()) throw this->fail("appendSet");
+}
+
+void HybridAsn::appendSet2() {
+  this->beginCall();
+  appendSet2_impl();
+}
+void HybridAsn::appendSet2_impl() {
+  if (!this->ck().AppendSet2()) throw this->fail("appendSet2");
+}
+
+std::shared_ptr<HybridAsnSpec> HybridAsn::appendSetR() {
+  this->beginCall();
+  return appendSetR_impl();
+}
+std::shared_ptr<HybridAsnSpec> HybridAsn::appendSetR_impl() {
+  CkAsn* _r = this->ck().AppendSetR();
+  if (!_r) throw this->fail("appendSetR");
+  return std::make_shared<HybridAsn>(_r);
+}
+
+void HybridAsn::appendString(const std::string& strType, const std::string& value) {
+  this->beginCall();
+  appendString_impl(strType, value);
+}
+void HybridAsn::appendString_impl(const std::string& strType, const std::string& value) {
+  rt::checkNoNul(strType, "strType");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().AppendString(strType.c_str(), value.c_str())) throw this->fail("appendString");
+}
+
+void HybridAsn::appendTime(const std::string& timeFormat, const std::string& dateTimeStr) {
+  this->beginCall();
+  appendTime_impl(timeFormat, dateTimeStr);
+}
+void HybridAsn::appendTime_impl(const std::string& timeFormat, const std::string& dateTimeStr) {
+  rt::checkNoNul(timeFormat, "timeFormat");
+  rt::checkNoNul(dateTimeStr, "dateTimeStr");
+  if (!this->ck().AppendTime(timeFormat.c_str(), dateTimeStr.c_str())) throw this->fail("appendTime");
+}
+
+std::string HybridAsn::asnToXml() {
+  this->beginCall();
+  return asnToXml_impl();
+}
+std::string HybridAsn::asnToXml_impl() {
+  CkString _out;
+  if (!this->ck().AsnToXml(_out)) throw this->fail("asnToXml");
+  return rt::stdString(_out);
+}
+
+void HybridAsn::deleteSubItem(double index) {
+  this->beginCall();
+  deleteSubItem_impl(index);
+}
+void HybridAsn::deleteSubItem_impl(double index) {
+  if (!this->ck().DeleteSubItem(rt::toInt(index, "index"))) throw this->fail("deleteSubItem");
+}
+
+std::string HybridAsn::getEncodedContent(const std::string& encoding) {
+  this->beginCall();
+  return getEncodedContent_impl(encoding);
+}
+std::string HybridAsn::getEncodedContent_impl(const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetEncodedContent(encoding.c_str(), _out)) throw this->fail("getEncodedContent");
+  return rt::stdString(_out);
+}
+
+std::string HybridAsn::getEncodedDer(const std::string& encoding) {
+  this->beginCall();
+  return getEncodedDer_impl(encoding);
+}
+std::string HybridAsn::getEncodedDer_impl(const std::string& encoding) {
+  rt::checkNoNul(encoding, "encoding");
+  CkString _out;
+  if (!this->ck().GetEncodedDer(encoding.c_str(), _out)) throw this->fail("getEncodedDer");
+  return rt::stdString(_out);
+}
+
+std::shared_ptr<HybridAsnSpec> HybridAsn::getLastSubItem() {
+  this->beginCall();
+  return getLastSubItem_impl();
+}
+std::shared_ptr<HybridAsnSpec> HybridAsn::getLastSubItem_impl() {
+  CkAsn* _r = this->ck().GetLastSubItem();
+  if (!_r) throw this->fail("getLastSubItem");
+  return std::make_shared<HybridAsn>(_r);
+}
+
+std::shared_ptr<HybridAsnSpec> HybridAsn::getSubItem(double index) {
+  this->beginCall();
+  return getSubItem_impl(index);
+}
+std::shared_ptr<HybridAsnSpec> HybridAsn::getSubItem_impl(double index) {
+  CkAsn* _r = this->ck().GetSubItem(rt::toInt(index, "index"));
+  if (!_r) throw this->fail("getSubItem");
+  return std::make_shared<HybridAsn>(_r);
+}
+
+void HybridAsn::loadAsnXml(const std::string& xmlStr) {
+  this->beginCall();
+  loadAsnXml_impl(xmlStr);
+}
+void HybridAsn::loadAsnXml_impl(const std::string& xmlStr) {
+  rt::checkNoNul(xmlStr, "xmlStr");
+  if (!this->ck().LoadAsnXml(xmlStr.c_str())) throw this->fail("loadAsnXml");
+}
+
+void HybridAsn::loadBinaryFile(const std::string& path) {
+  this->beginCall();
+  loadBinaryFile_impl(path);
+}
+void HybridAsn::loadBinaryFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().LoadBinaryFile(path.c_str())) throw this->fail("loadBinaryFile");
+}
+
+void HybridAsn::loadEncoded(const std::string& asnContent, const std::string& encoding) {
+  this->beginCall();
+  loadEncoded_impl(asnContent, encoding);
+}
+void HybridAsn::loadEncoded_impl(const std::string& asnContent, const std::string& encoding) {
+  rt::checkNoNul(asnContent, "asnContent");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().LoadEncoded(asnContent.c_str(), encoding.c_str())) throw this->fail("loadEncoded");
+}
+
+void HybridAsn::setEncodedContent(const std::string& encodedBytes, const std::string& encoding) {
+  this->beginCall();
+  setEncodedContent_impl(encodedBytes, encoding);
+}
+void HybridAsn::setEncodedContent_impl(const std::string& encodedBytes, const std::string& encoding) {
+  rt::checkNoNul(encodedBytes, "encodedBytes");
+  rt::checkNoNul(encoding, "encoding");
+  if (!this->ck().SetEncodedContent(encodedBytes.c_str(), encoding.c_str())) throw this->fail("setEncodedContent");
+}
+
+void HybridAsn::writeBinaryDer(const std::string& path) {
+  this->beginCall();
+  writeBinaryDer_impl(path);
+}
+void HybridAsn::writeBinaryDer_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().WriteBinaryDer(path.c_str())) throw this->fail("writeBinaryDer");
+}
+
+void HybridAsn::loadBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  loadBd_impl(bd);
+}
+void HybridAsn::loadBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().LoadBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("loadBd");
+}
+
+void HybridAsn::writeBd(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  writeBd_impl(bd);
+}
+void HybridAsn::writeBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().WriteBd(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("writeBd");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridAsn.hpp

@@ -0,0 +1,105 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Asn: the Nitro HybridObject over Chilkat's CkAsn (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridAsnSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkAsn.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridAsn final : public HybridAsnSpec, public ChilkatObject<CkAsn> {
+public:
+  HybridAsn();                                  // `new Asn()` from JS
+  explicit HybridAsn(CkAsn* 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;
+  bool getBoolValue() override;
+  void setBoolValue(bool value) override;
+  bool getConstructed() override;
+  std::string getContentStr() override;
+  void setContentStr(const std::string& value) override;
+  double getIntValue() override;
+  void setIntValue(double value) override;
+  double getNumSubItems() override;
+  std::string getTag() override;
+  double getTagValue() override;
+
+  // ---- Methods ----
+  void appendBigInt(const std::string& encodedBytes, const std::string& encoding) override;
+  void appendBits(const std::string& encodedBytes, const std::string& encoding) override;
+  void appendBool(bool value) override;
+  void appendContextConstructed(double tag) override;
+  void appendContextPrimitive(double tag, const std::string& encodedBytes, const std::string& encoding) override;
+  void appendInt(double value) override;
+  void appendNull() override;
+  void appendOctets(const std::string& encodedBytes, const std::string& encoding) override;
+  void appendOid(const std::string& oid) override;
+  void appendSequence() override;
+  void appendSequence2() override;
+  std::shared_ptr<HybridAsnSpec> appendSequenceR() override;
+  void appendSet() override;
+  void appendSet2() override;
+  std::shared_ptr<HybridAsnSpec> appendSetR() override;
+  void appendString(const std::string& strType, const std::string& value) override;
+  void appendTime(const std::string& timeFormat, const std::string& dateTimeStr) override;
+  std::string asnToXml() override;
+  void deleteSubItem(double index) override;
+  std::string getEncodedContent(const std::string& encoding) override;
+  std::string getEncodedDer(const std::string& encoding) override;
+  std::shared_ptr<HybridAsnSpec> getLastSubItem() override;
+  std::shared_ptr<HybridAsnSpec> getSubItem(double index) override;
+  void loadAsnXml(const std::string& xmlStr) override;
+  void loadBinaryFile(const std::string& path) override;
+  void loadEncoded(const std::string& asnContent, const std::string& encoding) override;
+  void setEncodedContent(const std::string& encodedBytes, const std::string& encoding) override;
+  void writeBinaryDer(const std::string& path) override;
+  void loadBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+  void writeBd(const std::shared_ptr<HybridBinDataSpec>& bd) override;
+
+private:
+  void init();
+  void appendBigInt_impl(const std::string& encodedBytes, const std::string& encoding);
+  void appendBits_impl(const std::string& encodedBytes, const std::string& encoding);
+  void appendBool_impl(bool value);
+  void appendContextConstructed_impl(double tag);
+  void appendContextPrimitive_impl(double tag, const std::string& encodedBytes, const std::string& encoding);
+  void appendInt_impl(double value);
+  void appendNull_impl();
+  void appendOctets_impl(const std::string& encodedBytes, const std::string& encoding);
+  void appendOid_impl(const std::string& oid);
+  void appendSequence_impl();
+  void appendSequence2_impl();
+  std::shared_ptr<HybridAsnSpec> appendSequenceR_impl();
+  void appendSet_impl();
+  void appendSet2_impl();
+  std::shared_ptr<HybridAsnSpec> appendSetR_impl();
+  void appendString_impl(const std::string& strType, const std::string& value);
+  void appendTime_impl(const std::string& timeFormat, const std::string& dateTimeStr);
+  std::string asnToXml_impl();
+  void deleteSubItem_impl(double index);
+  std::string getEncodedContent_impl(const std::string& encoding);
+  std::string getEncodedDer_impl(const std::string& encoding);
+  std::shared_ptr<HybridAsnSpec> getLastSubItem_impl();
+  std::shared_ptr<HybridAsnSpec> getSubItem_impl(double index);
+  void loadAsnXml_impl(const std::string& xmlStr);
+  void loadBinaryFile_impl(const std::string& path);
+  void loadEncoded_impl(const std::string& asnContent, const std::string& encoding);
+  void setEncodedContent_impl(const std::string& encodedBytes, const std::string& encoding);
+  void writeBinaryDer_impl(const std::string& path);
+  void loadBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+  void writeBd_impl(const std::shared_ptr<HybridBinDataSpec>& bd);
+};
+
+} // namespace margelo::nitro::chilkat