@chilkat/react-native 11.6.1

package/cpp/HybridMcp.cpp

@@ -0,0 +1,322 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridMcp.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridSocket.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridMcp::HybridMcp()
+    : HybridObject(HybridMcpSpec::TAG), ChilkatObject<CkMcp>("Mcp", CkMcp::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridMcp::HybridMcp(CkMcp* owned)
+    : HybridObject(HybridMcpSpec::TAG), ChilkatObject<CkMcp>("Mcp", owned) {
+  init();
+}
+
+void HybridMcp::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridMcp::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridMcp::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMcp::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMcp::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMcp::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMcp::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridMcp::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridMcp::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridMcp::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridMcp::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridMcp::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridMcp::getAuthToken() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_AuthToken(_s);
+  return rt::stdString(_s);
+}
+void HybridMcp::setAuthToken(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "authToken");
+  this->ck().put_AuthToken(value.c_str());
+}
+std::string HybridMcp::getSessionId() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_SessionId(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMcp::getProtocolVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProtocolVersion(_s);
+  return rt::stdString(_s);
+}
+void HybridMcp::setProtocolVersion(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "protocolVersion");
+  this->ck().put_ProtocolVersion(value.c_str());
+}
+std::string HybridMcp::getServerName() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ServerName(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMcp::getServerVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ServerVersion(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMcp::getServerInstructions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ServerInstructions(_s);
+  return rt::stdString(_s);
+}
+bool HybridMcp::getConnected() {
+  this->beginCall();
+  return this->ck().get_Connected();
+}
+double HybridMcp::getIdleTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_IdleTimeoutMs());
+}
+void HybridMcp::setIdleTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_IdleTimeoutMs(rt::toInt(value, "idleTimeoutMs"));
+}
+double HybridMcp::getConnectTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectTimeoutMs());
+}
+void HybridMcp::setConnectTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_ConnectTimeoutMs(rt::toInt(value, "connectTimeoutMs"));
+}
+double HybridMcp::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridMcp::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+
+// ---- Methods ----
+
+void HybridMcp::connect(const std::string& url) {
+  this->beginCall();
+  connect_impl(url);
+}
+void HybridMcp::connect_impl(const std::string& url) {
+  rt::checkNoNul(url, "url");
+  if (!this->ck().Connect(url.c_str())) throw this->fail("connect");
+}
+std::shared_ptr<Promise<void>> HybridMcp::connectAsync(const std::string& url) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMcp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Mcp.connectAsync", std::move(_parts), [_self, url]() {
+    _self->connect_impl(url);
+  });
+}
+
+void HybridMcp::close() {
+  this->beginCall();
+  close_impl();
+}
+void HybridMcp::close_impl() {
+  if (!this->ck().Close()) throw this->fail("close");
+}
+std::shared_ptr<Promise<void>> HybridMcp::closeAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMcp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Mcp.closeAsync", std::move(_parts), [_self]() {
+    _self->close_impl();
+  });
+}
+
+void HybridMcp::listTools(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  listTools_impl(json);
+}
+void HybridMcp::listTools_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().ListTools(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("listTools");
+}
+std::shared_ptr<Promise<void>> HybridMcp::listToolsAsync(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMcp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(json);
+  return rt::runAsync<void>("Mcp.listToolsAsync", std::move(_parts), [_self, json]() {
+    _self->listTools_impl(json);
+  });
+}
+
+void HybridMcp::callTool(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) {
+  this->beginCall();
+  callTool_impl(name, argsJson, resultJson);
+}
+void HybridMcp::callTool_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().CallTool(name.c_str(), rt::implOf<HybridJsonObject>(argsJson, "argsJson").ck(), rt::implOf<HybridJsonObject>(resultJson, "resultJson").ck())) throw this->fail("callTool");
+}
+std::shared_ptr<Promise<void>> HybridMcp::callToolAsync(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMcp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(argsJson);
+  _parts.push_back(resultJson);
+  return rt::runAsync<void>("Mcp.callToolAsync", std::move(_parts), [_self, name, argsJson, resultJson]() {
+    _self->callTool_impl(name, argsJson, resultJson);
+  });
+}
+
+void HybridMcp::listResources(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  listResources_impl(json);
+}
+void HybridMcp::listResources_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().ListResources(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("listResources");
+}
+std::shared_ptr<Promise<void>> HybridMcp::listResourcesAsync(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMcp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(json);
+  return rt::runAsync<void>("Mcp.listResourcesAsync", std::move(_parts), [_self, json]() {
+    _self->listResources_impl(json);
+  });
+}
+
+void HybridMcp::readResource(const std::string& uri, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  readResource_impl(uri, json);
+}
+void HybridMcp::readResource_impl(const std::string& uri, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  rt::checkNoNul(uri, "uri");
+  if (!this->ck().ReadResource(uri.c_str(), rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("readResource");
+}
+std::shared_ptr<Promise<void>> HybridMcp::readResourceAsync(const std::string& uri, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMcp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(json);
+  return rt::runAsync<void>("Mcp.readResourceAsync", std::move(_parts), [_self, uri, json]() {
+    _self->readResource_impl(uri, json);
+  });
+}
+
+void HybridMcp::listPrompts(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  listPrompts_impl(json);
+}
+void HybridMcp::listPrompts_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  if (!this->ck().ListPrompts(rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("listPrompts");
+}
+std::shared_ptr<Promise<void>> HybridMcp::listPromptsAsync(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMcp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(json);
+  return rt::runAsync<void>("Mcp.listPromptsAsync", std::move(_parts), [_self, json]() {
+    _self->listPrompts_impl(json);
+  });
+}
+
+void HybridMcp::getPrompt(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getPrompt_impl(name, argsJson, json);
+}
+void HybridMcp::getPrompt_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().GetPrompt(name.c_str(), rt::implOf<HybridJsonObject>(argsJson, "argsJson").ck(), rt::implOf<HybridJsonObject>(json, "json").ck())) throw this->fail("getPrompt");
+}
+std::shared_ptr<Promise<void>> HybridMcp::getPromptAsync(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridMcp>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(argsJson);
+  _parts.push_back(json);
+  return rt::runAsync<void>("Mcp.getPromptAsync", std::move(_parts), [_self, name, argsJson, json]() {
+    _self->getPrompt_impl(name, argsJson, json);
+  });
+}
+
+void HybridMcp::setConnectionSettings(const std::shared_ptr<HybridSocketSpec>& sock) {
+  this->beginCall();
+  setConnectionSettings_impl(sock);
+}
+void HybridMcp::setConnectionSettings_impl(const std::shared_ptr<HybridSocketSpec>& sock) {
+  if (!this->ck().SetConnectionSettings(rt::implOf<HybridSocket>(sock, "sock").ck())) throw this->fail("setConnectionSettings");
+}
+
+void HybridMcp::getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getLastJsonData_impl(json);
+}
+void HybridMcp::getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->ck().GetLastJsonData(rt::implOf<HybridJsonObject>(json, "json").ck());
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridMcp::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridMcp::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridMcp::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridMcp::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridMcp::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridMcp.hpp

@@ -0,0 +1,85 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Mcp: the Nitro HybridObject over Chilkat's CkMcp (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridMcpSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkMcp.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridMcp final : public HybridMcpSpec, public ChilkatObject<CkMcp> {
+public:
+  HybridMcp();                                  // `new Mcp()` from JS
+  explicit HybridMcp(CkMcp* 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 getAuthToken() override;
+  void setAuthToken(const std::string& value) override;
+  std::string getSessionId() override;
+  std::string getProtocolVersion() override;
+  void setProtocolVersion(const std::string& value) override;
+  std::string getServerName() override;
+  std::string getServerVersion() override;
+  std::string getServerInstructions() override;
+  bool getConnected() override;
+  double getIdleTimeoutMs() override;
+  void setIdleTimeoutMs(double value) override;
+  double getConnectTimeoutMs() override;
+  void setConnectTimeoutMs(double value) override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+
+  // ---- Methods ----
+  void connect(const std::string& url) override;
+  std::shared_ptr<Promise<void>> connectAsync(const std::string& url) override;
+  void close() override;
+  std::shared_ptr<Promise<void>> closeAsync() override;
+  void listTools(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  std::shared_ptr<Promise<void>> listToolsAsync(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void callTool(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) override;
+  std::shared_ptr<Promise<void>> callToolAsync(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) override;
+  void listResources(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  std::shared_ptr<Promise<void>> listResourcesAsync(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void readResource(const std::string& uri, const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  std::shared_ptr<Promise<void>> readResourceAsync(const std::string& uri, const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void listPrompts(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  std::shared_ptr<Promise<void>> listPromptsAsync(const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void getPrompt(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  std::shared_ptr<Promise<void>> getPromptAsync(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& json) override;
+  void setConnectionSettings(const std::shared_ptr<HybridSocketSpec>& sock) 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 connect_impl(const std::string& url);
+  void close_impl();
+  void listTools_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void callTool_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& resultJson);
+  void listResources_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void readResource_impl(const std::string& uri, const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void listPrompts_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void getPrompt_impl(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& json);
+  void setConnectionSettings_impl(const std::shared_ptr<HybridSocketSpec>& sock);
+  void getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json);
+};
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridMessageSet.cpp

@@ -0,0 +1,162 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridMessageSet.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridMessageSet::HybridMessageSet()
+    : HybridObject(HybridMessageSetSpec::TAG), ChilkatObject<CkMessageSet>("MessageSet", CkMessageSet::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridMessageSet::HybridMessageSet(CkMessageSet* owned)
+    : HybridObject(HybridMessageSetSpec::TAG), ChilkatObject<CkMessageSet>("MessageSet", owned) {
+  init();
+}
+
+void HybridMessageSet::init() {
+}
+
+void HybridMessageSet::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridMessageSet::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMessageSet::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMessageSet::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMessageSet::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridMessageSet::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridMessageSet::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridMessageSet::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridMessageSet::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridMessageSet::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridMessageSet::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+double HybridMessageSet::getCount() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_Count());
+}
+bool HybridMessageSet::getHasUids() {
+  this->beginCall();
+  return this->ck().get_HasUids();
+}
+void HybridMessageSet::setHasUids(bool value) {
+  this->beginCall();
+  this->ck().put_HasUids(value);
+}
+
+// ---- Methods ----
+
+bool HybridMessageSet::containsId(double msgId) {
+  this->beginCall();
+  return containsId_impl(msgId);
+}
+bool HybridMessageSet::containsId_impl(double msgId) {
+  return this->ck().ContainsId(rt::toULong(msgId, "msgId"));
+}
+
+void HybridMessageSet::fromCompactString(const std::string& str) {
+  this->beginCall();
+  fromCompactString_impl(str);
+}
+void HybridMessageSet::fromCompactString_impl(const std::string& str) {
+  rt::checkNoNul(str, "str");
+  if (!this->ck().FromCompactString(str.c_str())) throw this->fail("fromCompactString");
+}
+
+double HybridMessageSet::getId(double index) {
+  this->beginCall();
+  return getId_impl(index);
+}
+double HybridMessageSet::getId_impl(double index) {
+  return static_cast<double>(this->ck().GetId(rt::toInt(index, "index")));
+}
+
+void HybridMessageSet::insertId(double id) {
+  this->beginCall();
+  insertId_impl(id);
+}
+void HybridMessageSet::insertId_impl(double id) {
+  this->ck().InsertId(rt::toULong(id, "id"));
+}
+
+void HybridMessageSet::removeId(double id) {
+  this->beginCall();
+  removeId_impl(id);
+}
+void HybridMessageSet::removeId_impl(double id) {
+  this->ck().RemoveId(rt::toULong(id, "id"));
+}
+
+std::string HybridMessageSet::toCommaSeparatedStr() {
+  this->beginCall();
+  return toCommaSeparatedStr_impl();
+}
+std::string HybridMessageSet::toCommaSeparatedStr_impl() {
+  CkString _out;
+  if (!this->ck().ToCommaSeparatedStr(_out)) throw this->fail("toCommaSeparatedStr");
+  return rt::stdString(_out);
+}
+
+std::string HybridMessageSet::toCompactString() {
+  this->beginCall();
+  return toCompactString_impl();
+}
+std::string HybridMessageSet::toCompactString_impl() {
+  CkString _out;
+  if (!this->ck().ToCompactString(_out)) throw this->fail("toCompactString");
+  return rt::stdString(_out);
+}
+
+void HybridMessageSet::subtract(const std::shared_ptr<HybridMessageSetSpec>& msgSet) {
+  this->beginCall();
+  subtract_impl(msgSet);
+}
+void HybridMessageSet::subtract_impl(const std::shared_ptr<HybridMessageSetSpec>& msgSet) {
+  this->ck().Subtract(rt::implOf<HybridMessageSet>(msgSet, "msgSet").ck());
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridMessageSet.hpp

@@ -0,0 +1,54 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// MessageSet: the Nitro HybridObject over Chilkat's CkMessageSet (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridMessageSetSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkMessageSet.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridMessageSet final : public HybridMessageSetSpec, public ChilkatObject<CkMessageSet> {
+public:
+  HybridMessageSet();                                  // `new MessageSet()` from JS
+  explicit HybridMessageSet(CkMessageSet* owned);  // wraps an object a Chilkat method returned
+  void dispose() override;
+
+  // ---- Properties ----
+  std::string getLastErrorHtml() override;
+  std::string getLastErrorText() override;
+  std::string getLastErrorXml() override;
+  std::string getVersion() override;
+  std::string getDebugLogFilePath() override;
+  void setDebugLogFilePath(const std::string& value) override;
+  bool getVerboseLogging() override;
+  void setVerboseLogging(bool value) override;
+  bool getLastMethodSuccess() override;
+  void setLastMethodSuccess(bool value) override;
+  double getCount() override;
+  bool getHasUids() override;
+  void setHasUids(bool value) override;
+
+  // ---- Methods ----
+  bool containsId(double msgId) override;
+  void fromCompactString(const std::string& str) override;
+  double getId(double index) override;
+  void insertId(double id) override;
+  void removeId(double id) override;
+  std::string toCommaSeparatedStr() override;
+  std::string toCompactString() override;
+  void subtract(const std::shared_ptr<HybridMessageSetSpec>& msgSet) override;
+
+private:
+  void init();
+  bool containsId_impl(double msgId);
+  void fromCompactString_impl(const std::string& str);
+  double getId_impl(double index);
+  void insertId_impl(double id);
+  void removeId_impl(double id);
+  std::string toCommaSeparatedStr_impl();
+  std::string toCompactString_impl();
+  void subtract_impl(const std::shared_ptr<HybridMessageSetSpec>& msgSet);
+};
+
+} // namespace margelo::nitro::chilkat