@chilkat/react-native 11.6.1

package/cpp/HybridSpider.cpp

@@ -0,0 +1,543 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridSpider.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridSpider::HybridSpider()
+    : HybridObject(HybridSpiderSpec::TAG), ChilkatObject<CkSpider>("Spider", CkSpider::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridSpider::HybridSpider(CkSpider* owned)
+    : HybridObject(HybridSpiderSpec::TAG), ChilkatObject<CkSpider>("Spider", owned) {
+  init();
+}
+
+void HybridSpider::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridSpider::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridSpider::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSpider::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSpider::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSpider::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSpider::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridSpider::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridSpider::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridSpider::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridSpider::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridSpider::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+bool HybridSpider::getAvoidHttps() {
+  this->beginCall();
+  return this->ck().get_AvoidHttps();
+}
+void HybridSpider::setAvoidHttps(bool value) {
+  this->beginCall();
+  this->ck().put_AvoidHttps(value);
+}
+std::string HybridSpider::getCacheDir() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_CacheDir(_s);
+  return rt::stdString(_s);
+}
+void HybridSpider::setCacheDir(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "cacheDir");
+  this->ck().put_CacheDir(value.c_str());
+}
+bool HybridSpider::getChopAtQuery() {
+  this->beginCall();
+  return this->ck().get_ChopAtQuery();
+}
+void HybridSpider::setChopAtQuery(bool value) {
+  this->beginCall();
+  this->ck().put_ChopAtQuery(value);
+}
+double HybridSpider::getConnectTimeout() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectTimeout());
+}
+void HybridSpider::setConnectTimeout(double value) {
+  this->beginCall();
+  this->ck().put_ConnectTimeout(rt::toInt(value, "connectTimeout"));
+}
+std::string HybridSpider::getDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Domain(_s);
+  return rt::stdString(_s);
+}
+bool HybridSpider::getFetchFromCache() {
+  this->beginCall();
+  return this->ck().get_FetchFromCache();
+}
+void HybridSpider::setFetchFromCache(bool value) {
+  this->beginCall();
+  this->ck().put_FetchFromCache(value);
+}
+double HybridSpider::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridSpider::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+bool HybridSpider::getLastFromCache() {
+  this->beginCall();
+  return this->ck().get_LastFromCache();
+}
+std::string HybridSpider::getLastHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSpider::getLastHtmlDescription() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastHtmlDescription(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSpider::getLastHtmlKeywords() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastHtmlKeywords(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSpider::getLastHtmlTitle() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastHtmlTitle(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSpider::getLastModDateStr() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastModDateStr(_s);
+  return rt::stdString(_s);
+}
+std::string HybridSpider::getLastUrl() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastUrl(_s);
+  return rt::stdString(_s);
+}
+double HybridSpider::getMaxResponseSize() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_MaxResponseSize());
+}
+void HybridSpider::setMaxResponseSize(double value) {
+  this->beginCall();
+  this->ck().put_MaxResponseSize(rt::toInt(value, "maxResponseSize"));
+}
+double HybridSpider::getMaxUrlLen() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_MaxUrlLen());
+}
+void HybridSpider::setMaxUrlLen(double value) {
+  this->beginCall();
+  this->ck().put_MaxUrlLen(rt::toInt(value, "maxUrlLen"));
+}
+double HybridSpider::getNumAvoidPatterns() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumAvoidPatterns());
+}
+double HybridSpider::getNumFailed() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumFailed());
+}
+double HybridSpider::getNumOutboundLinks() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumOutboundLinks());
+}
+double HybridSpider::getNumSpidered() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumSpidered());
+}
+double HybridSpider::getNumUnspidered() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumUnspidered());
+}
+bool HybridSpider::getPreferIpv6() {
+  this->beginCall();
+  return this->ck().get_PreferIpv6();
+}
+void HybridSpider::setPreferIpv6(bool value) {
+  this->beginCall();
+  this->ck().put_PreferIpv6(value);
+}
+std::string HybridSpider::getProxyDomain() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyDomain(_s);
+  return rt::stdString(_s);
+}
+void HybridSpider::setProxyDomain(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyDomain");
+  this->ck().put_ProxyDomain(value.c_str());
+}
+std::string HybridSpider::getProxyLogin() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyLogin(_s);
+  return rt::stdString(_s);
+}
+void HybridSpider::setProxyLogin(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyLogin");
+  this->ck().put_ProxyLogin(value.c_str());
+}
+std::string HybridSpider::getProxyPassword() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ProxyPassword(_s);
+  return rt::stdString(_s);
+}
+void HybridSpider::setProxyPassword(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "proxyPassword");
+  this->ck().put_ProxyPassword(value.c_str());
+}
+double HybridSpider::getProxyPort() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ProxyPort());
+}
+void HybridSpider::setProxyPort(double value) {
+  this->beginCall();
+  this->ck().put_ProxyPort(rt::toInt(value, "proxyPort"));
+}
+double HybridSpider::getReadTimeout() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ReadTimeout());
+}
+void HybridSpider::setReadTimeout(double value) {
+  this->beginCall();
+  this->ck().put_ReadTimeout(rt::toInt(value, "readTimeout"));
+}
+bool HybridSpider::getUpdateCache() {
+  this->beginCall();
+  return this->ck().get_UpdateCache();
+}
+void HybridSpider::setUpdateCache(bool value) {
+  this->beginCall();
+  this->ck().put_UpdateCache(value);
+}
+std::string HybridSpider::getUserAgent() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UserAgent(_s);
+  return rt::stdString(_s);
+}
+void HybridSpider::setUserAgent(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "userAgent");
+  this->ck().put_UserAgent(value.c_str());
+}
+double HybridSpider::getWindDownCount() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_WindDownCount());
+}
+void HybridSpider::setWindDownCount(double value) {
+  this->beginCall();
+  this->ck().put_WindDownCount(rt::toInt(value, "windDownCount"));
+}
+bool HybridSpider::getAbortCurrent() {
+  this->beginCall();
+  return this->ck().get_AbortCurrent();
+}
+void HybridSpider::setAbortCurrent(bool value) {
+  this->beginCall();
+  this->ck().put_AbortCurrent(value);
+}
+bool HybridSpider::getWasRedirected() {
+  this->beginCall();
+  return this->ck().get_WasRedirected();
+}
+std::string HybridSpider::getFinalRedirectUrl() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_FinalRedirectUrl(_s);
+  return rt::stdString(_s);
+}
+
+// ---- Methods ----
+
+void HybridSpider::addAvoidOutboundLinkPattern(const std::string& pattern) {
+  this->beginCall();
+  addAvoidOutboundLinkPattern_impl(pattern);
+}
+void HybridSpider::addAvoidOutboundLinkPattern_impl(const std::string& pattern) {
+  rt::checkNoNul(pattern, "pattern");
+  this->ck().AddAvoidOutboundLinkPattern(pattern.c_str());
+}
+
+void HybridSpider::addAvoidPattern(const std::string& pattern) {
+  this->beginCall();
+  addAvoidPattern_impl(pattern);
+}
+void HybridSpider::addAvoidPattern_impl(const std::string& pattern) {
+  rt::checkNoNul(pattern, "pattern");
+  this->ck().AddAvoidPattern(pattern.c_str());
+}
+
+void HybridSpider::addMustMatchPattern(const std::string& pattern) {
+  this->beginCall();
+  addMustMatchPattern_impl(pattern);
+}
+void HybridSpider::addMustMatchPattern_impl(const std::string& pattern) {
+  rt::checkNoNul(pattern, "pattern");
+  this->ck().AddMustMatchPattern(pattern.c_str());
+}
+
+void HybridSpider::addUnspidered(const std::string& url) {
+  this->beginCall();
+  addUnspidered_impl(url);
+}
+void HybridSpider::addUnspidered_impl(const std::string& url) {
+  rt::checkNoNul(url, "url");
+  this->ck().AddUnspidered(url.c_str());
+}
+
+std::string HybridSpider::canonicalizeUrl(const std::string& url) {
+  this->beginCall();
+  return canonicalizeUrl_impl(url);
+}
+std::string HybridSpider::canonicalizeUrl_impl(const std::string& url) {
+  rt::checkNoNul(url, "url");
+  CkString _out;
+  if (!this->ck().CanonicalizeUrl(url.c_str(), _out)) throw this->fail("canonicalizeUrl");
+  return rt::stdString(_out);
+}
+
+void HybridSpider::clearFailedUrls() {
+  this->beginCall();
+  clearFailedUrls_impl();
+}
+void HybridSpider::clearFailedUrls_impl() {
+  this->ck().ClearFailedUrls();
+}
+
+void HybridSpider::clearOutboundLinks() {
+  this->beginCall();
+  clearOutboundLinks_impl();
+}
+void HybridSpider::clearOutboundLinks_impl() {
+  this->ck().ClearOutboundLinks();
+}
+
+void HybridSpider::clearSpideredUrls() {
+  this->beginCall();
+  clearSpideredUrls_impl();
+}
+void HybridSpider::clearSpideredUrls_impl() {
+  this->ck().ClearSpideredUrls();
+}
+
+void HybridSpider::crawlNext() {
+  this->beginCall();
+  crawlNext_impl();
+}
+void HybridSpider::crawlNext_impl() {
+  if (!this->ck().CrawlNext()) throw this->fail("crawlNext");
+}
+std::shared_ptr<Promise<void>> HybridSpider::crawlNextAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSpider>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Spider.crawlNextAsync", std::move(_parts), [_self]() {
+    _self->crawlNext_impl();
+  });
+}
+
+std::string HybridSpider::fetchRobotsText() {
+  this->beginCall();
+  return fetchRobotsText_impl();
+}
+std::string HybridSpider::fetchRobotsText_impl() {
+  CkString _out;
+  if (!this->ck().FetchRobotsText(_out)) throw this->fail("fetchRobotsText");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridSpider::fetchRobotsTextAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSpider>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Spider.fetchRobotsTextAsync", std::move(_parts), [_self]() {
+    return _self->fetchRobotsText_impl();
+  });
+}
+
+std::string HybridSpider::getAvoidPattern(double index) {
+  this->beginCall();
+  return getAvoidPattern_impl(index);
+}
+std::string HybridSpider::getAvoidPattern_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetAvoidPattern(rt::toInt(index, "index"), _out)) throw this->fail("getAvoidPattern");
+  return rt::stdString(_out);
+}
+
+std::string HybridSpider::getBaseDomain(const std::string& domain) {
+  this->beginCall();
+  return getBaseDomain_impl(domain);
+}
+std::string HybridSpider::getBaseDomain_impl(const std::string& domain) {
+  rt::checkNoNul(domain, "domain");
+  CkString _out;
+  if (!this->ck().GetBaseDomain(domain.c_str(), _out)) throw this->fail("getBaseDomain");
+  return rt::stdString(_out);
+}
+
+std::string HybridSpider::getFailedUrl(double index) {
+  this->beginCall();
+  return getFailedUrl_impl(index);
+}
+std::string HybridSpider::getFailedUrl_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetFailedUrl(rt::toInt(index, "index"), _out)) throw this->fail("getFailedUrl");
+  return rt::stdString(_out);
+}
+
+std::string HybridSpider::getOutboundLink(double index) {
+  this->beginCall();
+  return getOutboundLink_impl(index);
+}
+std::string HybridSpider::getOutboundLink_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetOutboundLink(rt::toInt(index, "index"), _out)) throw this->fail("getOutboundLink");
+  return rt::stdString(_out);
+}
+
+std::string HybridSpider::getSpideredUrl(double index) {
+  this->beginCall();
+  return getSpideredUrl_impl(index);
+}
+std::string HybridSpider::getSpideredUrl_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetSpideredUrl(rt::toInt(index, "index"), _out)) throw this->fail("getSpideredUrl");
+  return rt::stdString(_out);
+}
+
+std::string HybridSpider::getUnspideredUrl(double index) {
+  this->beginCall();
+  return getUnspideredUrl_impl(index);
+}
+std::string HybridSpider::getUnspideredUrl_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetUnspideredUrl(rt::toInt(index, "index"), _out)) throw this->fail("getUnspideredUrl");
+  return rt::stdString(_out);
+}
+
+std::string HybridSpider::getUrlDomain(const std::string& url) {
+  this->beginCall();
+  return getUrlDomain_impl(url);
+}
+std::string HybridSpider::getUrlDomain_impl(const std::string& url) {
+  rt::checkNoNul(url, "url");
+  CkString _out;
+  if (!this->ck().GetUrlDomain(url.c_str(), _out)) throw this->fail("getUrlDomain");
+  return rt::stdString(_out);
+}
+
+void HybridSpider::initialize(const std::string& domain) {
+  this->beginCall();
+  initialize_impl(domain);
+}
+void HybridSpider::initialize_impl(const std::string& domain) {
+  rt::checkNoNul(domain, "domain");
+  this->ck().Initialize(domain.c_str());
+}
+
+void HybridSpider::recrawlLast() {
+  this->beginCall();
+  recrawlLast_impl();
+}
+void HybridSpider::recrawlLast_impl() {
+  if (!this->ck().RecrawlLast()) throw this->fail("recrawlLast");
+}
+std::shared_ptr<Promise<void>> HybridSpider::recrawlLastAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridSpider>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Spider.recrawlLastAsync", std::move(_parts), [_self]() {
+    _self->recrawlLast_impl();
+  });
+}
+
+void HybridSpider::skipUnspidered(double index) {
+  this->beginCall();
+  skipUnspidered_impl(index);
+}
+void HybridSpider::skipUnspidered_impl(double index) {
+  this->ck().SkipUnspidered(rt::toInt(index, "index"));
+}
+
+void HybridSpider::sleepMs(double numMilliseconds) {
+  this->beginCall();
+  sleepMs_impl(numMilliseconds);
+}
+void HybridSpider::sleepMs_impl(double numMilliseconds) {
+  this->ck().SleepMs(rt::toInt(numMilliseconds, "numMilliseconds"));
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridSpider::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridSpider::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridSpider::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridSpider::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridSpider::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridSpider.hpp

@@ -0,0 +1,138 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// Spider: the Nitro HybridObject over Chilkat's CkSpider (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridSpiderSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkSpider.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridSpider final : public HybridSpiderSpec, public ChilkatObject<CkSpider> {
+public:
+  HybridSpider();                                  // `new Spider()` from JS
+  explicit HybridSpider(CkSpider* 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 getAvoidHttps() override;
+  void setAvoidHttps(bool value) override;
+  std::string getCacheDir() override;
+  void setCacheDir(const std::string& value) override;
+  bool getChopAtQuery() override;
+  void setChopAtQuery(bool value) override;
+  double getConnectTimeout() override;
+  void setConnectTimeout(double value) override;
+  std::string getDomain() override;
+  bool getFetchFromCache() override;
+  void setFetchFromCache(bool value) override;
+  double getHeartbeatMs() override;
+  void setHeartbeatMs(double value) override;
+  bool getLastFromCache() override;
+  std::string getLastHtml() override;
+  std::string getLastHtmlDescription() override;
+  std::string getLastHtmlKeywords() override;
+  std::string getLastHtmlTitle() override;
+  std::string getLastModDateStr() override;
+  std::string getLastUrl() override;
+  double getMaxResponseSize() override;
+  void setMaxResponseSize(double value) override;
+  double getMaxUrlLen() override;
+  void setMaxUrlLen(double value) override;
+  double getNumAvoidPatterns() override;
+  double getNumFailed() override;
+  double getNumOutboundLinks() override;
+  double getNumSpidered() override;
+  double getNumUnspidered() override;
+  bool getPreferIpv6() override;
+  void setPreferIpv6(bool value) override;
+  std::string getProxyDomain() override;
+  void setProxyDomain(const std::string& value) override;
+  std::string getProxyLogin() override;
+  void setProxyLogin(const std::string& value) override;
+  std::string getProxyPassword() override;
+  void setProxyPassword(const std::string& value) override;
+  double getProxyPort() override;
+  void setProxyPort(double value) override;
+  double getReadTimeout() override;
+  void setReadTimeout(double value) override;
+  bool getUpdateCache() override;
+  void setUpdateCache(bool value) override;
+  std::string getUserAgent() override;
+  void setUserAgent(const std::string& value) override;
+  double getWindDownCount() override;
+  void setWindDownCount(double value) override;
+  bool getAbortCurrent() override;
+  void setAbortCurrent(bool value) override;
+  bool getWasRedirected() override;
+  std::string getFinalRedirectUrl() override;
+
+  // ---- Methods ----
+  void addAvoidOutboundLinkPattern(const std::string& pattern) override;
+  void addAvoidPattern(const std::string& pattern) override;
+  void addMustMatchPattern(const std::string& pattern) override;
+  void addUnspidered(const std::string& url) override;
+  std::string canonicalizeUrl(const std::string& url) override;
+  void clearFailedUrls() override;
+  void clearOutboundLinks() override;
+  void clearSpideredUrls() override;
+  void crawlNext() override;
+  std::shared_ptr<Promise<void>> crawlNextAsync() override;
+  std::string fetchRobotsText() override;
+  std::shared_ptr<Promise<std::string>> fetchRobotsTextAsync() override;
+  std::string getAvoidPattern(double index) override;
+  std::string getBaseDomain(const std::string& domain) override;
+  std::string getFailedUrl(double index) override;
+  std::string getOutboundLink(double index) override;
+  std::string getSpideredUrl(double index) override;
+  std::string getUnspideredUrl(double index) override;
+  std::string getUrlDomain(const std::string& url) override;
+  void initialize(const std::string& domain) override;
+  void recrawlLast() override;
+  std::shared_ptr<Promise<void>> recrawlLastAsync() override;
+  void skipUnspidered(double index) override;
+  void sleepMs(double numMilliseconds) 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 addAvoidOutboundLinkPattern_impl(const std::string& pattern);
+  void addAvoidPattern_impl(const std::string& pattern);
+  void addMustMatchPattern_impl(const std::string& pattern);
+  void addUnspidered_impl(const std::string& url);
+  std::string canonicalizeUrl_impl(const std::string& url);
+  void clearFailedUrls_impl();
+  void clearOutboundLinks_impl();
+  void clearSpideredUrls_impl();
+  void crawlNext_impl();
+  std::string fetchRobotsText_impl();
+  std::string getAvoidPattern_impl(double index);
+  std::string getBaseDomain_impl(const std::string& domain);
+  std::string getFailedUrl_impl(double index);
+  std::string getOutboundLink_impl(double index);
+  std::string getSpideredUrl_impl(double index);
+  std::string getUnspideredUrl_impl(double index);
+  std::string getUrlDomain_impl(const std::string& url);
+  void initialize_impl(const std::string& domain);
+  void recrawlLast_impl();
+  void skipUnspidered_impl(double index);
+  void sleepMs_impl(double numMilliseconds);
+};
+
+} // namespace margelo::nitro::chilkat