@chilkat/react-native 11.6.1

package/cpp/HybridHttpRequest.cpp

@@ -0,0 +1,455 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+#include "HybridHttpRequest.hpp"
+#include "HybridBinData.hpp"
+#include "HybridStringBuilder.hpp"
+#include "runtime/AsyncCall.hpp"
+#include "runtime/Bytes.hpp"
+#include "runtime/ProgLang.hpp"
+
+namespace margelo::nitro::chilkat {
+
+HybridHttpRequest::HybridHttpRequest()
+    : HybridObject(HybridHttpRequestSpec::TAG), ChilkatObject<CkHttpRequest>("HttpRequest", CkHttpRequest::createNew2(PROGLANG_REACT_NATIVE)) {
+  init();
+}
+
+HybridHttpRequest::HybridHttpRequest(CkHttpRequest* owned)
+    : HybridObject(HybridHttpRequestSpec::TAG), ChilkatObject<CkHttpRequest>("HttpRequest", owned) {
+  init();
+}
+
+void HybridHttpRequest::init() {
+}
+
+void HybridHttpRequest::dispose() {
+  this->disposeChilkat();
+}
+
+// ---- Properties ----
+std::string HybridHttpRequest::getLastErrorHtml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorHtml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpRequest::getLastErrorText() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorText(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpRequest::getLastErrorXml() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_LastErrorXml(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpRequest::getVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Version(_s);
+  return rt::stdString(_s);
+}
+std::string HybridHttpRequest::getDebugLogFilePath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_DebugLogFilePath(_s);
+  return rt::stdString(_s);
+}
+void HybridHttpRequest::setDebugLogFilePath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "debugLogFilePath");
+  this->ck().put_DebugLogFilePath(value.c_str());
+}
+bool HybridHttpRequest::getVerboseLogging() {
+  this->beginCall();
+  return this->ck().get_VerboseLogging();
+}
+void HybridHttpRequest::setVerboseLogging(bool value) {
+  this->beginCall();
+  this->ck().put_VerboseLogging(value);
+}
+bool HybridHttpRequest::getLastMethodSuccess() {
+  this->beginCall();
+  return this->ck().get_LastMethodSuccess();
+}
+void HybridHttpRequest::setLastMethodSuccess(bool value) {
+  this->beginCall();
+  this->ck().put_LastMethodSuccess(value);
+}
+std::string HybridHttpRequest::getBoundary() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Boundary(_s);
+  return rt::stdString(_s);
+}
+void HybridHttpRequest::setBoundary(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "boundary");
+  this->ck().put_Boundary(value.c_str());
+}
+std::string HybridHttpRequest::getCharset() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Charset(_s);
+  return rt::stdString(_s);
+}
+void HybridHttpRequest::setCharset(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "charset");
+  this->ck().put_Charset(value.c_str());
+}
+std::string HybridHttpRequest::getContentType() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_ContentType(_s);
+  return rt::stdString(_s);
+}
+void HybridHttpRequest::setContentType(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "contentType");
+  this->ck().put_ContentType(value.c_str());
+}
+std::string HybridHttpRequest::getEntireHeader() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_EntireHeader(_s);
+  return rt::stdString(_s);
+}
+void HybridHttpRequest::setEntireHeader(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "entireHeader");
+  this->ck().put_EntireHeader(value.c_str());
+}
+std::string HybridHttpRequest::getHttpVerb() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpVerb(_s);
+  return rt::stdString(_s);
+}
+void HybridHttpRequest::setHttpVerb(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpVerb");
+  this->ck().put_HttpVerb(value.c_str());
+}
+std::string HybridHttpRequest::getHttpVersion() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_HttpVersion(_s);
+  return rt::stdString(_s);
+}
+void HybridHttpRequest::setHttpVersion(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "httpVersion");
+  this->ck().put_HttpVersion(value.c_str());
+}
+double HybridHttpRequest::getNumHeaderFields() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumHeaderFields());
+}
+double HybridHttpRequest::getNumParams() {
+  this->beginCall();
+  return static_cast<double>(this->ck().get_NumParams());
+}
+std::string HybridHttpRequest::getPath() {
+  this->beginCall();
+  CkString _s;
+  this->ck().get_Path(_s);
+  return rt::stdString(_s);
+}
+void HybridHttpRequest::setPath(const std::string& value) {
+  this->beginCall();
+  rt::checkNoNul(value, "path");
+  this->ck().put_Path(value.c_str());
+}
+bool HybridHttpRequest::getSendCharset() {
+  this->beginCall();
+  return this->ck().get_SendCharset();
+}
+void HybridHttpRequest::setSendCharset(bool value) {
+  this->beginCall();
+  this->ck().put_SendCharset(value);
+}
+
+// ---- Methods ----
+
+void HybridHttpRequest::addFileForUpload(const std::string& name, const std::string& filePath) {
+  this->beginCall();
+  addFileForUpload_impl(name, filePath);
+}
+void HybridHttpRequest::addFileForUpload_impl(const std::string& name, const std::string& filePath) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(filePath, "filePath");
+  if (!this->ck().AddFileForUpload(name.c_str(), filePath.c_str())) throw this->fail("addFileForUpload");
+}
+
+void HybridHttpRequest::addFileForUpload2(const std::string& name, const std::string& filePath, const std::string& contentType) {
+  this->beginCall();
+  addFileForUpload2_impl(name, filePath, contentType);
+}
+void HybridHttpRequest::addFileForUpload2_impl(const std::string& name, const std::string& filePath, const std::string& contentType) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(filePath, "filePath");
+  rt::checkNoNul(contentType, "contentType");
+  if (!this->ck().AddFileForUpload2(name.c_str(), filePath.c_str(), contentType.c_str())) throw this->fail("addFileForUpload2");
+}
+
+void HybridHttpRequest::addHeader(const std::string& name, const std::string& value) {
+  this->beginCall();
+  addHeader_impl(name, value);
+}
+void HybridHttpRequest::addHeader_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  this->ck().AddHeader(name.c_str(), value.c_str());
+}
+
+void HybridHttpRequest::addParam(const std::string& name, const std::string& value) {
+  this->beginCall();
+  addParam_impl(name, value);
+}
+void HybridHttpRequest::addParam_impl(const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  this->ck().AddParam(name.c_str(), value.c_str());
+}
+
+void HybridHttpRequest::addStringForUpload(const std::string& name, const std::string& filename, const std::string& strData, const std::string& charset) {
+  this->beginCall();
+  addStringForUpload_impl(name, filename, strData, charset);
+}
+void HybridHttpRequest::addStringForUpload_impl(const std::string& name, const std::string& filename, const std::string& strData, const std::string& charset) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(filename, "filename");
+  rt::checkNoNul(strData, "strData");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().AddStringForUpload(name.c_str(), filename.c_str(), strData.c_str(), charset.c_str())) throw this->fail("addStringForUpload");
+}
+
+void HybridHttpRequest::addStringForUpload2(const std::string& name, const std::string& filename, const std::string& strData, const std::string& charset, const std::string& contentType) {
+  this->beginCall();
+  addStringForUpload2_impl(name, filename, strData, charset, contentType);
+}
+void HybridHttpRequest::addStringForUpload2_impl(const std::string& name, const std::string& filename, const std::string& strData, const std::string& charset, const std::string& contentType) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(filename, "filename");
+  rt::checkNoNul(strData, "strData");
+  rt::checkNoNul(charset, "charset");
+  rt::checkNoNul(contentType, "contentType");
+  if (!this->ck().AddStringForUpload2(name.c_str(), filename.c_str(), strData.c_str(), charset.c_str(), contentType.c_str())) throw this->fail("addStringForUpload2");
+}
+
+void HybridHttpRequest::addSubHeader(double index, const std::string& name, const std::string& value) {
+  this->beginCall();
+  addSubHeader_impl(index, name, value);
+}
+void HybridHttpRequest::addSubHeader_impl(double index, const std::string& name, const std::string& value) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(value, "value");
+  if (!this->ck().AddSubHeader(rt::toInt(index, "index"), name.c_str(), value.c_str())) throw this->fail("addSubHeader");
+}
+
+std::string HybridHttpRequest::generateRequestText() {
+  this->beginCall();
+  return generateRequestText_impl();
+}
+std::string HybridHttpRequest::generateRequestText_impl() {
+  CkString _out;
+  if (!this->ck().GenerateRequestText(_out)) throw this->fail("generateRequestText");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttpRequest::getHeaderField(const std::string& name) {
+  this->beginCall();
+  return getHeaderField_impl(name);
+}
+std::string HybridHttpRequest::getHeaderField_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  CkString _out;
+  if (!this->ck().GetHeaderField(name.c_str(), _out)) throw this->fail("getHeaderField");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttpRequest::getHeaderName(double index) {
+  this->beginCall();
+  return getHeaderName_impl(index);
+}
+std::string HybridHttpRequest::getHeaderName_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetHeaderName(rt::toInt(index, "index"), _out)) throw this->fail("getHeaderName");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttpRequest::getHeaderValue(double index) {
+  this->beginCall();
+  return getHeaderValue_impl(index);
+}
+std::string HybridHttpRequest::getHeaderValue_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetHeaderValue(rt::toInt(index, "index"), _out)) throw this->fail("getHeaderValue");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttpRequest::getParam(const std::string& name) {
+  this->beginCall();
+  return getParam_impl(name);
+}
+std::string HybridHttpRequest::getParam_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  CkString _out;
+  if (!this->ck().GetParam(name.c_str(), _out)) throw this->fail("getParam");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttpRequest::getParamName(double index) {
+  this->beginCall();
+  return getParamName_impl(index);
+}
+std::string HybridHttpRequest::getParamName_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetParamName(rt::toInt(index, "index"), _out)) throw this->fail("getParamName");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttpRequest::getParamValue(double index) {
+  this->beginCall();
+  return getParamValue_impl(index);
+}
+std::string HybridHttpRequest::getParamValue_impl(double index) {
+  CkString _out;
+  if (!this->ck().GetParamValue(rt::toInt(index, "index"), _out)) throw this->fail("getParamValue");
+  return rt::stdString(_out);
+}
+
+std::string HybridHttpRequest::getUrlEncodedParams() {
+  this->beginCall();
+  return getUrlEncodedParams_impl();
+}
+std::string HybridHttpRequest::getUrlEncodedParams_impl() {
+  CkString _out;
+  if (!this->ck().GetUrlEncodedParams(_out)) throw this->fail("getUrlEncodedParams");
+  return rt::stdString(_out);
+}
+
+void HybridHttpRequest::loadBodyFromFile(const std::string& filePath) {
+  this->beginCall();
+  loadBodyFromFile_impl(filePath);
+}
+void HybridHttpRequest::loadBodyFromFile_impl(const std::string& filePath) {
+  rt::checkNoNul(filePath, "filePath");
+  if (!this->ck().LoadBodyFromFile(filePath.c_str())) throw this->fail("loadBodyFromFile");
+}
+
+void HybridHttpRequest::loadBodyFromString(const std::string& bodyStr, const std::string& charset) {
+  this->beginCall();
+  loadBodyFromString_impl(bodyStr, charset);
+}
+void HybridHttpRequest::loadBodyFromString_impl(const std::string& bodyStr, const std::string& charset) {
+  rt::checkNoNul(bodyStr, "bodyStr");
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().LoadBodyFromString(bodyStr.c_str(), charset.c_str())) throw this->fail("loadBodyFromString");
+}
+
+void HybridHttpRequest::removeAllParams() {
+  this->beginCall();
+  removeAllParams_impl();
+}
+void HybridHttpRequest::removeAllParams_impl() {
+  this->ck().RemoveAllParams();
+}
+
+void HybridHttpRequest::removeHeader(const std::string& name) {
+  this->beginCall();
+  removeHeader_impl(name);
+}
+void HybridHttpRequest::removeHeader_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  if (!this->ck().RemoveHeader(name.c_str())) throw this->fail("removeHeader");
+}
+
+void HybridHttpRequest::removeParam(const std::string& name) {
+  this->beginCall();
+  removeParam_impl(name);
+}
+void HybridHttpRequest::removeParam_impl(const std::string& name) {
+  rt::checkNoNul(name, "name");
+  this->ck().RemoveParam(name.c_str());
+}
+
+void HybridHttpRequest::setFromUrl(const std::string& url) {
+  this->beginCall();
+  setFromUrl_impl(url);
+}
+void HybridHttpRequest::setFromUrl_impl(const std::string& url) {
+  rt::checkNoNul(url, "url");
+  this->ck().SetFromUrl(url.c_str());
+}
+
+void HybridHttpRequest::streamBodyFromFile(const std::string& filePath) {
+  this->beginCall();
+  streamBodyFromFile_impl(filePath);
+}
+void HybridHttpRequest::streamBodyFromFile_impl(const std::string& filePath) {
+  rt::checkNoNul(filePath, "filePath");
+  if (!this->ck().StreamBodyFromFile(filePath.c_str())) throw this->fail("streamBodyFromFile");
+}
+
+void HybridHttpRequest::streamChunkFromFile(const std::string& path, const std::string& offset, const std::string& numBytes) {
+  this->beginCall();
+  streamChunkFromFile_impl(path, offset, numBytes);
+}
+void HybridHttpRequest::streamChunkFromFile_impl(const std::string& path, const std::string& offset, const std::string& numBytes) {
+  rt::checkNoNul(path, "path");
+  rt::checkNoNul(offset, "offset");
+  rt::checkNoNul(numBytes, "numBytes");
+  if (!this->ck().StreamChunkFromFile(path.c_str(), offset.c_str(), numBytes.c_str())) throw this->fail("streamChunkFromFile");
+}
+
+void HybridHttpRequest::generateRequestFile(const std::string& path) {
+  this->beginCall();
+  generateRequestFile_impl(path);
+}
+void HybridHttpRequest::generateRequestFile_impl(const std::string& path) {
+  rt::checkNoNul(path, "path");
+  if (!this->ck().GenerateRequestFile(path.c_str())) throw this->fail("generateRequestFile");
+}
+
+void HybridHttpRequest::addMwsSignature(const std::string& domain, const std::string& mwsSecretKey) {
+  this->beginCall();
+  addMwsSignature_impl(domain, mwsSecretKey);
+}
+void HybridHttpRequest::addMwsSignature_impl(const std::string& domain, const std::string& mwsSecretKey) {
+  rt::checkNoNul(domain, "domain");
+  rt::checkNoNul(mwsSecretKey, "mwsSecretKey");
+  if (!this->ck().AddMwsSignature(domain.c_str(), mwsSecretKey.c_str())) throw this->fail("addMwsSignature");
+}
+
+void HybridHttpRequest::loadBodyFromBd(const std::shared_ptr<HybridBinDataSpec>& requestBody) {
+  this->beginCall();
+  loadBodyFromBd_impl(requestBody);
+}
+void HybridHttpRequest::loadBodyFromBd_impl(const std::shared_ptr<HybridBinDataSpec>& requestBody) {
+  if (!this->ck().LoadBodyFromBd(rt::implOf<HybridBinData>(requestBody, "requestBody").ck())) throw this->fail("loadBodyFromBd");
+}
+
+void HybridHttpRequest::loadBodyFromSb(const std::shared_ptr<HybridStringBuilderSpec>& requestBody, const std::string& charset) {
+  this->beginCall();
+  loadBodyFromSb_impl(requestBody, charset);
+}
+void HybridHttpRequest::loadBodyFromSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& requestBody, const std::string& charset) {
+  rt::checkNoNul(charset, "charset");
+  if (!this->ck().LoadBodyFromSb(rt::implOf<HybridStringBuilder>(requestBody, "requestBody").ck(), charset.c_str())) throw this->fail("loadBodyFromSb");
+}
+
+void HybridHttpRequest::addBdForUpload(const std::string& name, const std::string& remoteFilename, const std::shared_ptr<HybridBinDataSpec>& byteData, const std::string& contentType) {
+  this->beginCall();
+  addBdForUpload_impl(name, remoteFilename, byteData, contentType);
+}
+void HybridHttpRequest::addBdForUpload_impl(const std::string& name, const std::string& remoteFilename, const std::shared_ptr<HybridBinDataSpec>& byteData, const std::string& contentType) {
+  rt::checkNoNul(name, "name");
+  rt::checkNoNul(remoteFilename, "remoteFilename");
+  rt::checkNoNul(contentType, "contentType");
+  if (!this->ck().AddBdForUpload(name.c_str(), remoteFilename.c_str(), rt::implOf<HybridBinData>(byteData, "byteData").ck(), contentType.c_str())) throw this->fail("addBdForUpload");
+}
+
+} // namespace margelo::nitro::chilkat

package/cpp/HybridHttpRequest.hpp

@@ -0,0 +1,109 @@
+// Generated by ReactNativeNs.RnGenerator -- do not edit.
+// HttpRequest: the Nitro HybridObject over Chilkat's CkHttpRequest (ReactNativeGen_DESIGN.md).
+#pragma once
+
+#include "HybridHttpRequestSpec.hpp"
+#include "runtime/ChilkatObject.hpp"
+#include <CkHttpRequest.h>
+
+namespace margelo::nitro::chilkat {
+
+class HybridHttpRequest final : public HybridHttpRequestSpec, public ChilkatObject<CkHttpRequest> {
+public:
+  HybridHttpRequest();                                  // `new HttpRequest()` from JS
+  explicit HybridHttpRequest(CkHttpRequest* 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 getBoundary() override;
+  void setBoundary(const std::string& value) override;
+  std::string getCharset() override;
+  void setCharset(const std::string& value) override;
+  std::string getContentType() override;
+  void setContentType(const std::string& value) override;
+  std::string getEntireHeader() override;
+  void setEntireHeader(const std::string& value) override;
+  std::string getHttpVerb() override;
+  void setHttpVerb(const std::string& value) override;
+  std::string getHttpVersion() override;
+  void setHttpVersion(const std::string& value) override;
+  double getNumHeaderFields() override;
+  double getNumParams() override;
+  std::string getPath() override;
+  void setPath(const std::string& value) override;
+  bool getSendCharset() override;
+  void setSendCharset(bool value) override;
+
+  // ---- Methods ----
+  void addFileForUpload(const std::string& name, const std::string& filePath) override;
+  void addFileForUpload2(const std::string& name, const std::string& filePath, const std::string& contentType) override;
+  void addHeader(const std::string& name, const std::string& value) override;
+  void addParam(const std::string& name, const std::string& value) override;
+  void addStringForUpload(const std::string& name, const std::string& filename, const std::string& strData, const std::string& charset) override;
+  void addStringForUpload2(const std::string& name, const std::string& filename, const std::string& strData, const std::string& charset, const std::string& contentType) override;
+  void addSubHeader(double index, const std::string& name, const std::string& value) override;
+  std::string generateRequestText() override;
+  std::string getHeaderField(const std::string& name) override;
+  std::string getHeaderName(double index) override;
+  std::string getHeaderValue(double index) override;
+  std::string getParam(const std::string& name) override;
+  std::string getParamName(double index) override;
+  std::string getParamValue(double index) override;
+  std::string getUrlEncodedParams() override;
+  void loadBodyFromFile(const std::string& filePath) override;
+  void loadBodyFromString(const std::string& bodyStr, const std::string& charset) override;
+  void removeAllParams() override;
+  void removeHeader(const std::string& name) override;
+  void removeParam(const std::string& name) override;
+  void setFromUrl(const std::string& url) override;
+  void streamBodyFromFile(const std::string& filePath) override;
+  void streamChunkFromFile(const std::string& path, const std::string& offset, const std::string& numBytes) override;
+  void generateRequestFile(const std::string& path) override;
+  void addMwsSignature(const std::string& domain, const std::string& mwsSecretKey) override;
+  void loadBodyFromBd(const std::shared_ptr<HybridBinDataSpec>& requestBody) override;
+  void loadBodyFromSb(const std::shared_ptr<HybridStringBuilderSpec>& requestBody, const std::string& charset) override;
+  void addBdForUpload(const std::string& name, const std::string& remoteFilename, const std::shared_ptr<HybridBinDataSpec>& byteData, const std::string& contentType) override;
+
+private:
+  void init();
+  void addFileForUpload_impl(const std::string& name, const std::string& filePath);
+  void addFileForUpload2_impl(const std::string& name, const std::string& filePath, const std::string& contentType);
+  void addHeader_impl(const std::string& name, const std::string& value);
+  void addParam_impl(const std::string& name, const std::string& value);
+  void addStringForUpload_impl(const std::string& name, const std::string& filename, const std::string& strData, const std::string& charset);
+  void addStringForUpload2_impl(const std::string& name, const std::string& filename, const std::string& strData, const std::string& charset, const std::string& contentType);
+  void addSubHeader_impl(double index, const std::string& name, const std::string& value);
+  std::string generateRequestText_impl();
+  std::string getHeaderField_impl(const std::string& name);
+  std::string getHeaderName_impl(double index);
+  std::string getHeaderValue_impl(double index);
+  std::string getParam_impl(const std::string& name);
+  std::string getParamName_impl(double index);
+  std::string getParamValue_impl(double index);
+  std::string getUrlEncodedParams_impl();
+  void loadBodyFromFile_impl(const std::string& filePath);
+  void loadBodyFromString_impl(const std::string& bodyStr, const std::string& charset);
+  void removeAllParams_impl();
+  void removeHeader_impl(const std::string& name);
+  void removeParam_impl(const std::string& name);
+  void setFromUrl_impl(const std::string& url);
+  void streamBodyFromFile_impl(const std::string& filePath);
+  void streamChunkFromFile_impl(const std::string& path, const std::string& offset, const std::string& numBytes);
+  void generateRequestFile_impl(const std::string& path);
+  void addMwsSignature_impl(const std::string& domain, const std::string& mwsSecretKey);
+  void loadBodyFromBd_impl(const std::shared_ptr<HybridBinDataSpec>& requestBody);
+  void loadBodyFromSb_impl(const std::shared_ptr<HybridStringBuilderSpec>& requestBody, const std::string& charset);
+  void addBdForUpload_impl(const std::string& name, const std::string& remoteFilename, const std::shared_ptr<HybridBinDataSpec>& byteData, const std::string& contentType);
+};
+
+} // namespace margelo::nitro::chilkat