@chilkat/react-native 11.6.1

package/cpp/HybridRest.cpp

@@ -0,0 +1,993 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridRest.hpp"
+#include "HybridAuthAws.hpp"
+#include "HybridAuthAzureSAS.hpp"
+#include "HybridAuthAzureStorage.hpp"
+#include "HybridAuthGoogle.hpp"
+#include "HybridBinData.hpp"
+#include "HybridJsonObject.hpp"
+#include "HybridOAuth1.hpp"
+#include "HybridOAuth2.hpp"
+#include "HybridSecureString.hpp"
+#include "HybridSocket.hpp"
+#include "HybridStream.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+#include "runtime/ProgressAdapter.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridRest::HybridRest()
+    : HybridObject(HybridRestSpec::TAG), ChilkatObject<CkRest>("Rest", CkRest::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridRest::HybridRest(CkRest* owned)
+    : HybridObject(HybridRestSpec::TAG), ChilkatObject<CkRest>("Rest", owned) {
+  init();
+}
+
+void HybridRest::init() {
+  this->installProgress<ProgressAdapter<CkBaseProgress>>();
+}
+
+void HybridRest::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridRest::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridRest::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridRest::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridRest::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridRest::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridRest::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridRest::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridRest::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridRest::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridRest::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridRest::getAuthorization() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Authorization(_s);
+  return rt::stdString(_s);
+}
+void HybridRest::setAuthorization(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "authorization");
+  this->ck().put_Authorization(value.c_str());
+}
+double HybridRest::getHeartbeatMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_HeartbeatMs());
+}
+void HybridRest::setHeartbeatMs(double value) {
+  this->beginCall();
+  this->ck().put_HeartbeatMs(rt::toInt(value, "heartbeatMs"));
+}
+std::string HybridRest::getHost() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Host(_s);
+  return rt::stdString(_s);
+}
+void HybridRest::setHost(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "host");
+  this->ck().put_Host(value.c_str());
+}
+double HybridRest::getIdleTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_IdleTimeoutMs());
+}
+void HybridRest::setIdleTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_IdleTimeoutMs(rt::toInt(value, "idleTimeoutMs"));
+}
+std::string HybridRest::getLastRequestHeader() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastRequestHeader(_s);
+  return rt::stdString(_s);
+}
+std::string HybridRest::getLastRequestStartLine() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastRequestStartLine(_s);
+  return rt::stdString(_s);
+}
+double HybridRest::getNumResponseHeaders() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumResponseHeaders());
+}
+std::string HybridRest::getPartSelector() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_PartSelector(_s);
+  return rt::stdString(_s);
+}
+void HybridRest::setPartSelector(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "partSelector");
+  this->ck().put_PartSelector(value.c_str());
+}
+std::string HybridRest::getResponseHeader() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ResponseHeader(_s);
+  return rt::stdString(_s);
+}
+double HybridRest::getResponseStatusCode() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ResponseStatusCode());
+}
+std::string HybridRest::getResponseStatusText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ResponseStatusText(_s);
+  return rt::stdString(_s);
+}
+bool HybridRest::getStreamNonChunked() {
+  this->beginCall();
+  return this->ck().get_StreamNonChunked();
+}
+void HybridRest::setStreamNonChunked(bool value) {
+  this->beginCall();
+  this->ck().put_StreamNonChunked(value);
+}
+double HybridRest::getConnectFailReason() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectFailReason());
+}
+bool HybridRest::getPercentDoneOnSend() {
+  this->beginCall();
+  return this->ck().get_PercentDoneOnSend();
+}
+void HybridRest::setPercentDoneOnSend(bool value) {
+  this->beginCall();
+  this->ck().put_PercentDoneOnSend(value);
+}
+bool HybridRest::getAllowHeaderQB() {
+  this->beginCall();
+  return this->ck().get_AllowHeaderQB();
+}
+void HybridRest::setAllowHeaderQB(bool value) {
+  this->beginCall();
+  this->ck().put_AllowHeaderQB(value);
+}
+bool HybridRest::getAllowHeaderFolding() {
+  this->beginCall();
+  return this->ck().get_AllowHeaderFolding();
+}
+void HybridRest::setAllowHeaderFolding(bool value) {
+  this->beginCall();
+  this->ck().put_AllowHeaderFolding(value);
+}
+double HybridRest::getConnectTimeoutMs() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_ConnectTimeoutMs());
+}
+void HybridRest::setConnectTimeoutMs(double value) {
+  this->beginCall();
+  this->ck().put_ConnectTimeoutMs(rt::toInt(value, "connectTimeoutMs"));
+}
+bool HybridRest::getDebugMode() {
+  this->beginCall();
+  return this->ck().get_DebugMode();
+}
+void HybridRest::setDebugMode(bool value) {
+  this->beginCall();
+  this->ck().put_DebugMode(value);
+}
+std::string HybridRest::getUncommonOptions() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_UncommonOptions(_s);
+  return rt::stdString(_s);
+}
+void HybridRest::setUncommonOptions(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "uncommonOptions");
+  this->ck().put_UncommonOptions(value.c_str());
+}
+std::string HybridRest::getLastRedirectUrl() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastRedirectUrl(_s);
+  return rt::stdString(_s);
+}
+bool HybridRest::getEnableSecrets() {
+  this->beginCall();
+  return this->ck().get_EnableSecrets();
+}
+void HybridRest::setEnableSecrets(bool value) {
+  this->beginCall();
+  this->ck().put_EnableSecrets(value);
+}
+
+// ---- Methods ----
+
+void HybridRest::addHeader(const std::string& name, const std::string& value) {
+  this->beginCall();
+  addHeader_impl(name, value);
+}
+void HybridRest::addHeader_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().AddHeader(name.c_str(), value.c_str())) throw this->fail("addHeader");
+}
+
+void HybridRest::addQueryParam(const std::string& name, const std::string& value) {
+  this->beginCall();
+  addQueryParam_impl(name, value);
+}
+void HybridRest::addQueryParam_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().AddQueryParam(name.c_str(), value.c_str())) throw this->fail("addQueryParam");
+}
+
+void HybridRest::addQueryParams(const std::string& queryString) {
+  this->beginCall();
+  addQueryParams_impl(queryString);
+}
+void HybridRest::addQueryParams_impl(const std::string& queryString) {
+  rt::checkNoNul(queryString, "queryString");
+  if (!this->ck().AddQueryParams(queryString.c_str())) throw this->fail("addQueryParams");
+}
+
+void HybridRest::clearAllHeaders() {
+  this->beginCall();
+  clearAllHeaders_impl();
+}
+void HybridRest::clearAllHeaders_impl() {
+  if (!this->ck().ClearAllHeaders()) throw this->fail("clearAllHeaders");
+}
+
+void HybridRest::clearAllQueryParams() {
+  this->beginCall();
+  clearAllQueryParams_impl();
+}
+void HybridRest::clearAllQueryParams_impl() {
+  if (!this->ck().ClearAllQueryParams()) throw this->fail("clearAllQueryParams");
+}
+
+void HybridRest::clearResponseBodyStream() {
+  this->beginCall();
+  clearResponseBodyStream_impl();
+}
+void HybridRest::clearResponseBodyStream_impl() {
+  this->ck().ClearResponseBodyStream();
+}
+
+void HybridRest::connect(const std::string& hostname, double port, bool tls, bool autoReconnect) {
+  this->beginCall();
+  connect_impl(hostname, port, tls, autoReconnect);
+}
+void HybridRest::connect_impl(const std::string& hostname, double port, bool tls, bool autoReconnect) {
+  rt::checkNoNul(hostname, "hostname");
+  if (!this->ck().Connect(hostname.c_str(), rt::toInt(port, "port"), tls, autoReconnect)) throw this->fail("connect");
+}
+std::shared_ptr<Promise<void>> HybridRest::connectAsync(const std::string& hostname, double port, bool tls, bool autoReconnect) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Rest.connectAsync", std::move(_parts), [_self, hostname, port, tls, autoReconnect]() {
+    _self->connect_impl(hostname, port, tls, autoReconnect);
+  });
+}
+
+void HybridRest::disconnect(double maxWaitMs) {
+  this->beginCall();
+  disconnect_impl(maxWaitMs);
+}
+void HybridRest::disconnect_impl(double maxWaitMs) {
+  if (!this->ck().Disconnect(rt::toInt(maxWaitMs, "maxWaitMs"))) throw this->fail("disconnect");
+}
+std::shared_ptr<Promise<void>> HybridRest::disconnectAsync(double maxWaitMs) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Rest.disconnectAsync", std::move(_parts), [_self, maxWaitMs]() {
+    _self->disconnect_impl(maxWaitMs);
+  });
+}
+
+std::string HybridRest::fullRequestFormUrlEncoded(const std::string& httpVerb, const std::string& uriPath) {
+  this->beginCall();
+  return fullRequestFormUrlEncoded_impl(httpVerb, uriPath);
+}
+std::string HybridRest::fullRequestFormUrlEncoded_impl(const std::string& httpVerb, const std::string& uriPath) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  CkString _out;
+  if (!this->ck().FullRequestFormUrlEncoded(httpVerb.c_str(), uriPath.c_str(), _out)) throw this->fail("fullRequestFormUrlEncoded");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridRest::fullRequestFormUrlEncodedAsync(const std::string& httpVerb, const std::string& uriPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Rest.fullRequestFormUrlEncodedAsync", std::move(_parts), [_self, httpVerb, uriPath]() {
+    return _self->fullRequestFormUrlEncoded_impl(httpVerb, uriPath);
+  });
+}
+
+std::string HybridRest::fullRequestMultipart(const std::string& httpVerb, const std::string& uriPath) {
+  this->beginCall();
+  return fullRequestMultipart_impl(httpVerb, uriPath);
+}
+std::string HybridRest::fullRequestMultipart_impl(const std::string& httpVerb, const std::string& uriPath) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  CkString _out;
+  if (!this->ck().FullRequestMultipart(httpVerb.c_str(), uriPath.c_str(), _out)) throw this->fail("fullRequestMultipart");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridRest::fullRequestMultipartAsync(const std::string& httpVerb, const std::string& uriPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Rest.fullRequestMultipartAsync", std::move(_parts), [_self, httpVerb, uriPath]() {
+    return _self->fullRequestMultipart_impl(httpVerb, uriPath);
+  });
+}
+
+std::string HybridRest::fullRequestNoBody(const std::string& httpVerb, const std::string& uriPath) {
+  this->beginCall();
+  return fullRequestNoBody_impl(httpVerb, uriPath);
+}
+std::string HybridRest::fullRequestNoBody_impl(const std::string& httpVerb, const std::string& uriPath) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  CkString _out;
+  if (!this->ck().FullRequestNoBody(httpVerb.c_str(), uriPath.c_str(), _out)) throw this->fail("fullRequestNoBody");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridRest::fullRequestNoBodyAsync(const std::string& httpVerb, const std::string& uriPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Rest.fullRequestNoBodyAsync", std::move(_parts), [_self, httpVerb, uriPath]() {
+    return _self->fullRequestNoBody_impl(httpVerb, uriPath);
+  });
+}
+
+std::string HybridRest::fullRequestStream(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream) {
+  this->beginCall();
+  return fullRequestStream_impl(httpVerb, uriPath, stream);
+}
+std::string HybridRest::fullRequestStream_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  CkString _out;
+  if (!this->ck().FullRequestStream(httpVerb.c_str(), uriPath.c_str(), rt::implOf<HybridStream>(stream, "stream").ck(), _out)) throw this->fail("fullRequestStream");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridRest::fullRequestStreamAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(stream);
+  return rt::runAsync<std::string>("Rest.fullRequestStreamAsync", std::move(_parts), [_self, httpVerb, uriPath, stream]() {
+    return _self->fullRequestStream_impl(httpVerb, uriPath, stream);
+  });
+}
+
+std::string HybridRest::fullRequestString(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText) {
+  this->beginCall();
+  return fullRequestString_impl(httpVerb, uriPath, bodyText);
+}
+std::string HybridRest::fullRequestString_impl(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  rt::checkNoNul(bodyText, "bodyText");
+  CkString _out;
+  if (!this->ck().FullRequestString(httpVerb.c_str(), uriPath.c_str(), bodyText.c_str(), _out)) throw this->fail("fullRequestString");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridRest::fullRequestStringAsync(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Rest.fullRequestStringAsync", std::move(_parts), [_self, httpVerb, uriPath, bodyText]() {
+    return _self->fullRequestString_impl(httpVerb, uriPath, bodyText);
+  });
+}
+
+void HybridRest::readRespBodyStream(const std::shared_ptr<HybridStreamSpec>& stream, bool autoSetStreamCharset) {
+  this->beginCall();
+  readRespBodyStream_impl(stream, autoSetStreamCharset);
+}
+void HybridRest::readRespBodyStream_impl(const std::shared_ptr<HybridStreamSpec>& stream, bool autoSetStreamCharset) {
+  if (!this->ck().ReadRespBodyStream(rt::implOf<HybridStream>(stream, "stream").ck(), autoSetStreamCharset)) throw this->fail("readRespBodyStream");
+}
+std::shared_ptr<Promise<void>> HybridRest::readRespBodyStreamAsync(const std::shared_ptr<HybridStreamSpec>& stream, bool autoSetStreamCharset) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(stream);
+  return rt::runAsync<void>("Rest.readRespBodyStreamAsync", std::move(_parts), [_self, stream, autoSetStreamCharset]() {
+    _self->readRespBodyStream_impl(stream, autoSetStreamCharset);
+  });
+}
+
+std::string HybridRest::readRespBodyString() {
+  this->beginCall();
+  return readRespBodyString_impl();
+}
+std::string HybridRest::readRespBodyString_impl() {
+  CkString _out;
+  if (!this->ck().ReadRespBodyString(_out)) throw this->fail("readRespBodyString");
+  return rt::stdString(_out);
+}
+std::shared_ptr<Promise<std::string>> HybridRest::readRespBodyStringAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<std::string>("Rest.readRespBodyStringAsync", std::move(_parts), [_self]() {
+    return _self->readRespBodyString_impl();
+  });
+}
+
+double HybridRest::readResponseHeader() {
+  this->beginCall();
+  return readResponseHeader_impl();
+}
+double HybridRest::readResponseHeader_impl() {
+  return static_cast<double>(this->ck().ReadResponseHeader());
+}
+std::shared_ptr<Promise<double>> HybridRest::readResponseHeaderAsync() {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<double>("Rest.readResponseHeaderAsync", std::move(_parts), [_self]() {
+    return _self->readResponseHeader_impl();
+  });
+}
+
+void HybridRest::removeHeader(const std::string& name) {
+  this->beginCall();
+  removeHeader_impl(name);
+}
+void HybridRest::removeHeader_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().RemoveHeader(name.c_str())) throw this->fail("removeHeader");
+}
+
+void HybridRest::removeQueryParam(const std::string& name) {
+  this->beginCall();
+  removeQueryParam_impl(name);
+}
+void HybridRest::removeQueryParam_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().RemoveQueryParam(name.c_str())) throw this->fail("removeQueryParam");
+}
+
+std::string HybridRest::responseHdrByName(const std::string& name) {
+  this->beginCall();
+  return responseHdrByName_impl(name);
+}
+std::string HybridRest::responseHdrByName_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  CkString _out;
+  if (!this->ck().ResponseHdrByName(name.c_str(), _out)) throw this->fail("responseHdrByName");
+  return rt::stdString(_out);
+}
+
+std::string HybridRest::responseHdrName(double index) {
+  this->beginCall();
+  return responseHdrName_impl(index);
+}
+std::string HybridRest::responseHdrName_impl(double index) {
+  CkString _out;
+  if (!this->ck().ResponseHdrName(rt::toInt(index, "index"), _out)) throw this->fail("responseHdrName");
+  return rt::stdString(_out);
+}
+
+std::string HybridRest::responseHdrValue(double index) {
+  this->beginCall();
+  return responseHdrValue_impl(index);
+}
+std::string HybridRest::responseHdrValue_impl(double index) {
+  CkString _out;
+  if (!this->ck().ResponseHdrValue(rt::toInt(index, "index"), _out)) throw this->fail("responseHdrValue");
+  return rt::stdString(_out);
+}
+
+void HybridRest::sendReqFormUrlEncoded(const std::string& httpVerb, const std::string& uriPath) {
+  this->beginCall();
+  sendReqFormUrlEncoded_impl(httpVerb, uriPath);
+}
+void HybridRest::sendReqFormUrlEncoded_impl(const std::string& httpVerb, const std::string& uriPath) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  if (!this->ck().SendReqFormUrlEncoded(httpVerb.c_str(), uriPath.c_str())) throw this->fail("sendReqFormUrlEncoded");
+}
+std::shared_ptr<Promise<void>> HybridRest::sendReqFormUrlEncodedAsync(const std::string& httpVerb, const std::string& uriPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Rest.sendReqFormUrlEncodedAsync", std::move(_parts), [_self, httpVerb, uriPath]() {
+    _self->sendReqFormUrlEncoded_impl(httpVerb, uriPath);
+  });
+}
+
+void HybridRest::sendReqMultipart(const std::string& httpVerb, const std::string& uriPath) {
+  this->beginCall();
+  sendReqMultipart_impl(httpVerb, uriPath);
+}
+void HybridRest::sendReqMultipart_impl(const std::string& httpVerb, const std::string& uriPath) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  if (!this->ck().SendReqMultipart(httpVerb.c_str(), uriPath.c_str())) throw this->fail("sendReqMultipart");
+}
+std::shared_ptr<Promise<void>> HybridRest::sendReqMultipartAsync(const std::string& httpVerb, const std::string& uriPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Rest.sendReqMultipartAsync", std::move(_parts), [_self, httpVerb, uriPath]() {
+    _self->sendReqMultipart_impl(httpVerb, uriPath);
+  });
+}
+
+void HybridRest::sendReqNoBody(const std::string& httpVerb, const std::string& uriPath) {
+  this->beginCall();
+  sendReqNoBody_impl(httpVerb, uriPath);
+}
+void HybridRest::sendReqNoBody_impl(const std::string& httpVerb, const std::string& uriPath) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  if (!this->ck().SendReqNoBody(httpVerb.c_str(), uriPath.c_str())) throw this->fail("sendReqNoBody");
+}
+std::shared_ptr<Promise<void>> HybridRest::sendReqNoBodyAsync(const std::string& httpVerb, const std::string& uriPath) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Rest.sendReqNoBodyAsync", std::move(_parts), [_self, httpVerb, uriPath]() {
+    _self->sendReqNoBody_impl(httpVerb, uriPath);
+  });
+}
+
+void HybridRest::sendReqStreamBody(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream) {
+  this->beginCall();
+  sendReqStreamBody_impl(httpVerb, uriPath, stream);
+}
+void HybridRest::sendReqStreamBody_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  if (!this->ck().SendReqStreamBody(httpVerb.c_str(), uriPath.c_str(), rt::implOf<HybridStream>(stream, "stream").ck())) throw this->fail("sendReqStreamBody");
+}
+std::shared_ptr<Promise<void>> HybridRest::sendReqStreamBodyAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStreamSpec>& stream) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(stream);
+  return rt::runAsync<void>("Rest.sendReqStreamBodyAsync", std::move(_parts), [_self, httpVerb, uriPath, stream]() {
+    _self->sendReqStreamBody_impl(httpVerb, uriPath, stream);
+  });
+}
+
+void HybridRest::sendReqStringBody(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText) {
+  this->beginCall();
+  sendReqStringBody_impl(httpVerb, uriPath, bodyText);
+}
+void HybridRest::sendReqStringBody_impl(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  rt::checkNoNul(bodyText, "bodyText");
+  if (!this->ck().SendReqStringBody(httpVerb.c_str(), uriPath.c_str(), bodyText.c_str())) throw this->fail("sendReqStringBody");
+}
+std::shared_ptr<Promise<void>> HybridRest::sendReqStringBodyAsync(const std::string& httpVerb, const std::string& uriPath, const std::string& bodyText) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  return rt::runAsync<void>("Rest.sendReqStringBodyAsync", std::move(_parts), [_self, httpVerb, uriPath, bodyText]() {
+    _self->sendReqStringBody_impl(httpVerb, uriPath, bodyText);
+  });
+}
+
+void HybridRest::setAuthAws(const std::shared_ptr<HybridAuthAwsSpec>& authProvider) {
+  this->beginCall();
+  setAuthAws_impl(authProvider);
+}
+void HybridRest::setAuthAws_impl(const std::shared_ptr<HybridAuthAwsSpec>& authProvider) {
+  if (!this->ck().SetAuthAws(rt::implOf<HybridAuthAws>(authProvider, "authProvider").ck())) throw this->fail("setAuthAws");
+}
+
+void HybridRest::setAuthAzureStorage(const std::shared_ptr<HybridAuthAzureStorageSpec>& authProvider) {
+  this->beginCall();
+  setAuthAzureStorage_impl(authProvider);
+}
+void HybridRest::setAuthAzureStorage_impl(const std::shared_ptr<HybridAuthAzureStorageSpec>& authProvider) {
+  if (!this->ck().SetAuthAzureStorage(rt::implOf<HybridAuthAzureStorage>(authProvider, "authProvider").ck())) throw this->fail("setAuthAzureStorage");
+}
+
+void HybridRest::setAuthBasic(const std::string& username, const std::string& password) {
+  this->beginCall();
+  setAuthBasic_impl(username, password);
+}
+void HybridRest::setAuthBasic_impl(const std::string& username, const std::string& password) {
+  rt::checkNoNul(username, "username");
+  rt::checkNoNul(password, "password");
+  if (!this->ck().SetAuthBasic(username.c_str(), password.c_str())) throw this->fail("setAuthBasic");
+}
+
+void HybridRest::setAuthGoogle(const std::shared_ptr<HybridAuthGoogleSpec>& authProvider) {
+  this->beginCall();
+  setAuthGoogle_impl(authProvider);
+}
+void HybridRest::setAuthGoogle_impl(const std::shared_ptr<HybridAuthGoogleSpec>& authProvider) {
+  if (!this->ck().SetAuthGoogle(rt::implOf<HybridAuthGoogle>(authProvider, "authProvider").ck())) throw this->fail("setAuthGoogle");
+}
+
+void HybridRest::setAuthOAuth1(const std::shared_ptr<HybridOAuth1Spec>& authProvider, bool useQueryParams) {
+  this->beginCall();
+  setAuthOAuth1_impl(authProvider, useQueryParams);
+}
+void HybridRest::setAuthOAuth1_impl(const std::shared_ptr<HybridOAuth1Spec>& authProvider, bool useQueryParams) {
+  if (!this->ck().SetAuthOAuth1(rt::implOf<HybridOAuth1>(authProvider, "authProvider").ck(), useQueryParams)) throw this->fail("setAuthOAuth1");
+}
+
+void HybridRest::setAuthOAuth2(const std::shared_ptr<HybridOAuth2Spec>& authProvider) {
+  this->beginCall();
+  setAuthOAuth2_impl(authProvider);
+}
+void HybridRest::setAuthOAuth2_impl(const std::shared_ptr<HybridOAuth2Spec>& authProvider) {
+  if (!this->ck().SetAuthOAuth2(rt::implOf<HybridOAuth2>(authProvider, "authProvider").ck())) throw this->fail("setAuthOAuth2");
+}
+
+void HybridRest::setMultipartBodyStream(const std::shared_ptr<HybridStreamSpec>& stream) {
+  this->beginCall();
+  setMultipartBodyStream_impl(stream);
+}
+void HybridRest::setMultipartBodyStream_impl(const std::shared_ptr<HybridStreamSpec>& stream) {
+  if (!this->ck().SetMultipartBodyStream(rt::implOf<HybridStream>(stream, "stream").ck())) throw this->fail("setMultipartBodyStream");
+}
+
+void HybridRest::setMultipartBodyString(const std::string& bodyText) {
+  this->beginCall();
+  setMultipartBodyString_impl(bodyText);
+}
+void HybridRest::setMultipartBodyString_impl(const std::string& bodyText) {
+  rt::checkNoNul(bodyText, "bodyText");
+  if (!this->ck().SetMultipartBodyString(bodyText.c_str())) throw this->fail("setMultipartBodyString");
+}
+
+void HybridRest::setResponseBodyStream(double expectedStatus, bool autoSetStreamCharset, const std::shared_ptr<HybridStreamSpec>& responseStream) {
+  this->beginCall();
+  setResponseBodyStream_impl(expectedStatus, autoSetStreamCharset, responseStream);
+}
+void HybridRest::setResponseBodyStream_impl(double expectedStatus, bool autoSetStreamCharset, const std::shared_ptr<HybridStreamSpec>& responseStream) {
+  if (!this->ck().SetResponseBodyStream(rt::toInt(expectedStatus, "expectedStatus"), autoSetStreamCharset, rt::implOf<HybridStream>(responseStream, "responseStream").ck())) throw this->fail("setResponseBodyStream");
+}
+
+void HybridRest::useConnection(const std::shared_ptr<HybridSocketSpec>& connection, bool autoReconnect) {
+  this->beginCall();
+  useConnection_impl(connection, autoReconnect);
+}
+void HybridRest::useConnection_impl(const std::shared_ptr<HybridSocketSpec>& connection, bool autoReconnect) {
+  if (!this->ck().UseConnection(rt::implOf<HybridSocket>(connection, "connection").ck(), autoReconnect)) throw this->fail("useConnection");
+}
+
+void HybridRest::fullRequestSb(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& requestBody, const std::shared_ptr<HybridStringBuilderSpec>& responseBody) {
+  this->beginCall();
+  fullRequestSb_impl(httpVerb, uriPath, requestBody, responseBody);
+}
+void HybridRest::fullRequestSb_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& requestBody, const std::shared_ptr<HybridStringBuilderSpec>& responseBody) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  if (!this->ck().FullRequestSb(httpVerb.c_str(), uriPath.c_str(), rt::implOf<HybridStringBuilder>(requestBody, "requestBody").ck(), rt::implOf<HybridStringBuilder>(responseBody, "responseBody").ck())) throw this->fail("fullRequestSb");
+}
+std::shared_ptr<Promise<void>> HybridRest::fullRequestSbAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& requestBody, const std::shared_ptr<HybridStringBuilderSpec>& responseBody) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(requestBody);
+  _parts.push_back(responseBody);
+  return rt::runAsync<void>("Rest.fullRequestSbAsync", std::move(_parts), [_self, httpVerb, uriPath, requestBody, responseBody]() {
+    _self->fullRequestSb_impl(httpVerb, uriPath, requestBody, responseBody);
+  });
+}
+
+void HybridRest::addQueryParamSb(const std::string& name, const std::shared_ptr<HybridStringBuilderSpec>& value) {
+  this->beginCall();
+  addQueryParamSb_impl(name, value);
+}
+void HybridRest::addQueryParamSb_impl(const std::string& name, const std::shared_ptr<HybridStringBuilderSpec>& value) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().AddQueryParamSb(name.c_str(), rt::implOf<HybridStringBuilder>(value, "value").ck())) throw this->fail("addQueryParamSb");
+}
+
+void HybridRest::setMultipartBodySb(const std::shared_ptr<HybridStringBuilderSpec>& bodySb) {
+  this->beginCall();
+  setMultipartBodySb_impl(bodySb);
+}
+void HybridRest::setMultipartBodySb_impl(const std::shared_ptr<HybridStringBuilderSpec>& bodySb) {
+  if (!this->ck().SetMultipartBodySb(rt::implOf<HybridStringBuilder>(bodySb, "bodySb").ck())) throw this->fail("setMultipartBodySb");
+}
+
+void HybridRest::setMultipartBodyBd(const std::shared_ptr<HybridBinDataSpec>& bodyData) {
+  this->beginCall();
+  setMultipartBodyBd_impl(bodyData);
+}
+void HybridRest::setMultipartBodyBd_impl(const std::shared_ptr<HybridBinDataSpec>& bodyData) {
+  if (!this->ck().SetMultipartBodyBd(rt::implOf<HybridBinData>(bodyData, "bodyData").ck())) throw this->fail("setMultipartBodyBd");
+}
+
+void HybridRest::sendReqSb(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& bodySb) {
+  this->beginCall();
+  sendReqSb_impl(httpVerb, uriPath, bodySb);
+}
+void HybridRest::sendReqSb_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& bodySb) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  if (!this->ck().SendReqSb(httpVerb.c_str(), uriPath.c_str(), rt::implOf<HybridStringBuilder>(bodySb, "bodySb").ck())) throw this->fail("sendReqSb");
+}
+std::shared_ptr<Promise<void>> HybridRest::sendReqSbAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& bodySb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bodySb);
+  return rt::runAsync<void>("Rest.sendReqSbAsync", std::move(_parts), [_self, httpVerb, uriPath, bodySb]() {
+    _self->sendReqSb_impl(httpVerb, uriPath, bodySb);
+  });
+}
+
+void HybridRest::sendReqBd(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& body) {
+  this->beginCall();
+  sendReqBd_impl(httpVerb, uriPath, body);
+}
+void HybridRest::sendReqBd_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& body) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  if (!this->ck().SendReqBd(httpVerb.c_str(), uriPath.c_str(), rt::implOf<HybridBinData>(body, "body").ck())) throw this->fail("sendReqBd");
+}
+std::shared_ptr<Promise<void>> HybridRest::sendReqBdAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& body) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(body);
+  return rt::runAsync<void>("Rest.sendReqBdAsync", std::move(_parts), [_self, httpVerb, uriPath, body]() {
+    _self->sendReqBd_impl(httpVerb, uriPath, body);
+  });
+}
+
+void HybridRest::readRespSb(const std::shared_ptr<HybridStringBuilderSpec>& responseBody) {
+  this->beginCall();
+  readRespSb_impl(responseBody);
+}
+void HybridRest::readRespSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& responseBody) {
+  if (!this->ck().ReadRespSb(rt::implOf<HybridStringBuilder>(responseBody, "responseBody").ck())) throw this->fail("readRespSb");
+}
+std::shared_ptr<Promise<void>> HybridRest::readRespSbAsync(const std::shared_ptr<HybridStringBuilderSpec>& responseBody) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(responseBody);
+  return rt::runAsync<void>("Rest.readRespSbAsync", std::move(_parts), [_self, responseBody]() {
+    _self->readRespSb_impl(responseBody);
+  });
+}
+
+void HybridRest::readRespBd(const std::shared_ptr<HybridBinDataSpec>& responseBody) {
+  this->beginCall();
+  readRespBd_impl(responseBody);
+}
+void HybridRest::readRespBd_impl(const std::shared_ptr<HybridBinDataSpec>& responseBody) {
+  if (!this->ck().ReadRespBd(rt::implOf<HybridBinData>(responseBody, "responseBody").ck())) throw this->fail("readRespBd");
+}
+std::shared_ptr<Promise<void>> HybridRest::readRespBdAsync(const std::shared_ptr<HybridBinDataSpec>& responseBody) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(responseBody);
+  return rt::runAsync<void>("Rest.readRespBdAsync", std::move(_parts), [_self, responseBody]() {
+    _self->readRespBd_impl(responseBody);
+  });
+}
+
+void HybridRest::clearAllParts() {
+  this->beginCall();
+  clearAllParts_impl();
+}
+void HybridRest::clearAllParts_impl() {
+  if (!this->ck().ClearAllParts()) throw this->fail("clearAllParts");
+}
+
+void HybridRest::fullRequestNoBodySb(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  fullRequestNoBodySb_impl(httpVerb, uriPath, sb);
+}
+void HybridRest::fullRequestNoBodySb_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  if (!this->ck().FullRequestNoBodySb(httpVerb.c_str(), uriPath.c_str(), rt::implOf<HybridStringBuilder>(sb, "sb").ck())) throw this->fail("fullRequestNoBodySb");
+}
+std::shared_ptr<Promise<void>> HybridRest::fullRequestNoBodySbAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridStringBuilderSpec>& sb) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(sb);
+  return rt::runAsync<void>("Rest.fullRequestNoBodySbAsync", std::move(_parts), [_self, httpVerb, uriPath, sb]() {
+    _self->fullRequestNoBodySb_impl(httpVerb, uriPath, sb);
+  });
+}
+
+void HybridRest::fullRequestBd(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& responseBody) {
+  this->beginCall();
+  fullRequestBd_impl(httpVerb, uriPath, binData, responseBody);
+}
+void HybridRest::fullRequestBd_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& responseBody) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  if (!this->ck().FullRequestBd(httpVerb.c_str(), uriPath.c_str(), rt::implOf<HybridBinData>(binData, "binData").ck(), rt::implOf<HybridStringBuilder>(responseBody, "responseBody").ck())) throw this->fail("fullRequestBd");
+}
+std::shared_ptr<Promise<void>> HybridRest::fullRequestBdAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData, const std::shared_ptr<HybridStringBuilderSpec>& responseBody) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  _parts.push_back(responseBody);
+  return rt::runAsync<void>("Rest.fullRequestBdAsync", std::move(_parts), [_self, httpVerb, uriPath, binData, responseBody]() {
+    _self->fullRequestBd_impl(httpVerb, uriPath, binData, responseBody);
+  });
+}
+
+void HybridRest::fullRequestNoBodyBd(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  fullRequestNoBodyBd_impl(httpVerb, uriPath, binData);
+}
+void HybridRest::fullRequestNoBodyBd_impl(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  if (!this->ck().FullRequestNoBodyBd(httpVerb.c_str(), uriPath.c_str(), rt::implOf<HybridBinData>(binData, "binData").ck())) throw this->fail("fullRequestNoBodyBd");
+}
+std::shared_ptr<Promise<void>> HybridRest::fullRequestNoBodyBdAsync(const std::string& httpVerb, const std::string& uriPath, const std::shared_ptr<HybridBinDataSpec>& binData) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(binData);
+  return rt::runAsync<void>("Rest.fullRequestNoBodyBdAsync", std::move(_parts), [_self, httpVerb, uriPath, binData]() {
+    _self->fullRequestNoBodyBd_impl(httpVerb, uriPath, binData);
+  });
+}
+
+void HybridRest::setAuthAzureSas(const std::shared_ptr<HybridAuthAzureSASSpec>& authProvider) {
+  this->beginCall();
+  setAuthAzureSas_impl(authProvider);
+}
+void HybridRest::setAuthAzureSas_impl(const std::shared_ptr<HybridAuthAzureSASSpec>& authProvider) {
+  if (!this->ck().SetAuthAzureSas(rt::implOf<HybridAuthAzureSAS>(authProvider, "authProvider").ck())) throw this->fail("setAuthAzureSas");
+}
+
+void HybridRest::addMwsSignature(const std::string& httpVerb, const std::string& uriPath, const std::string& domain, const std::string& mwsSecretKey) {
+  this->beginCall();
+  addMwsSignature_impl(httpVerb, uriPath, domain, mwsSecretKey);
+}
+void HybridRest::addMwsSignature_impl(const std::string& httpVerb, const std::string& uriPath, const std::string& domain, const std::string& mwsSecretKey) {
+  rt::checkNoNul(httpVerb, "httpVerb");
+  rt::checkNoNul(uriPath, "uriPath");
+  rt::checkNoNul(domain, "domain");
+  rt::checkNoNul(mwsSecretKey, "mwsSecretKey");
+  if (!this->ck().AddMwsSignature(httpVerb.c_str(), uriPath.c_str(), domain.c_str(), mwsSecretKey.c_str())) throw this->fail("addMwsSignature");
+}
+
+void HybridRest::clearAuth() {
+  this->beginCall();
+  clearAuth_impl();
+}
+void HybridRest::clearAuth_impl() {
+  if (!this->ck().ClearAuth()) throw this->fail("clearAuth");
+}
+
+void HybridRest::addPathParam(const std::string& name, const std::string& value) {
+  this->beginCall();
+  addPathParam_impl(name, value);
+}
+void HybridRest::addPathParam_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().AddPathParam(name.c_str(), value.c_str())) throw this->fail("addPathParam");
+}
+
+void HybridRest::clearAllPathParams() {
+  this->beginCall();
+  clearAllPathParams_impl();
+}
+void HybridRest::clearAllPathParams_impl() {
+  if (!this->ck().ClearAllPathParams()) throw this->fail("clearAllPathParams");
+}
+
+void HybridRest::setAuthBasicSecure(const std::shared_ptr<HybridSecureStringSpec>& username, const std::shared_ptr<HybridSecureStringSpec>& password) {
+  this->beginCall();
+  setAuthBasicSecure_impl(username, password);
+}
+void HybridRest::setAuthBasicSecure_impl(const std::shared_ptr<HybridSecureStringSpec>& username, const std::shared_ptr<HybridSecureStringSpec>& password) {
+  if (!this->ck().SetAuthBasicSecure(rt::implOf<HybridSecureString>(username, "username").ck(), rt::implOf<HybridSecureString>(password, "password").ck())) throw this->fail("setAuthBasicSecure");
+}
+
+void HybridRest::getLastDebugRequest(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  getLastDebugRequest_impl(bd);
+}
+void HybridRest::getLastDebugRequest_impl(const std::shared_ptr<HybridBinDataSpec>& bd) {
+  if (!this->ck().GetLastDebugRequest(rt::implOf<HybridBinData>(bd, "bd").ck())) throw this->fail("getLastDebugRequest");
+}
+
+double HybridRest::readRespChunkBd(double minSize, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  return readRespChunkBd_impl(minSize, bd);
+}
+double HybridRest::readRespChunkBd_impl(double minSize, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  return static_cast<double>(this->ck().ReadRespChunkBd(rt::toInt(minSize, "minSize"), rt::implOf<HybridBinData>(bd, "bd").ck()));
+}
+std::shared_ptr<Promise<double>> HybridRest::readRespChunkBdAsync(double minSize, const std::shared_ptr<HybridBinDataSpec>& bd) {
+  this->beginCall();
+  auto _self = this->shared_cast<HybridRest>();
+  std::vector<std::shared_ptr<HybridObject>> _parts{ _self };
+  _parts.push_back(bd);
+  return rt::runAsync<double>("Rest.readRespChunkBdAsync", std::move(_parts), [_self, minSize, bd]() {
+    return _self->readRespChunkBd_impl(minSize, bd);
+  });
+}
+
+void HybridRest::getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->beginCall();
+  getLastJsonData_impl(json);
+}
+void HybridRest::getLastJsonData_impl(const std::shared_ptr<HybridJsonObjectSpec>& json) {
+  this->ck().GetLastJsonData(rt::implOf<HybridJsonObject>(json, "json").ck());
+}
+
+// ---- Events ----
+std::optional<std::function<void(double)>> HybridRest::getOnPercentDone() { return this->getOnPercentDoneCb(); }
+void HybridRest::setOnPercentDone(const std::optional<std::function<void(double)>>& cb) { this->setOnPercentDoneCb(cb); }
+std::optional<std::function<void(const std::string&, const std::string&)>> HybridRest::getOnProgressInfo() { return this->getOnProgressInfoCb(); }
+void HybridRest::setOnProgressInfo(const std::optional<std::function<void(const std::string&, const std::string&)>>& cb) { this->setOnProgressInfoCb(cb); }
+void HybridRest::abort() { this->requestAbort(); }
+
+} // namespace margelo::nitro::chilkat