@chilkat/react-native 11.6.1

package/nitrogen/generated/shared/c++/HybridHttpCurlSpec.cpp

@@ -0,0 +1,67 @@
+///
+/// HybridHttpCurlSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridHttpCurlSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridHttpCurlSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridHttpCurlSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridHttpCurlSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridHttpCurlSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridHttpCurlSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridHttpCurlSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridHttpCurlSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridHttpCurlSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridHttpCurlSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridHttpCurlSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridHttpCurlSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("statusCode", &HybridHttpCurlSpec::getStatusCode);
+      prototype.registerHybridGetter("responseBodyStr", &HybridHttpCurlSpec::getResponseBodyStr);
+      prototype.registerHybridGetter("responseFilePath", &HybridHttpCurlSpec::getResponseFilePath);
+      prototype.registerHybridSetter("responseFilePath", &HybridHttpCurlSpec::setResponseFilePath);
+      prototype.registerHybridGetter("enableBodyVars", &HybridHttpCurlSpec::getEnableBodyVars);
+      prototype.registerHybridSetter("enableBodyVars", &HybridHttpCurlSpec::setEnableBodyVars);
+      prototype.registerHybridGetter("failReason", &HybridHttpCurlSpec::getFailReason);
+      prototype.registerHybridGetter("failedCurl", &HybridHttpCurlSpec::getFailedCurl);
+      prototype.registerHybridGetter("heartbeatMs", &HybridHttpCurlSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridHttpCurlSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("uncommonOptions", &HybridHttpCurlSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridHttpCurlSpec::setUncommonOptions);
+      prototype.registerHybridGetter("onPercentDone", &HybridHttpCurlSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridHttpCurlSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridHttpCurlSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridHttpCurlSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("doYourThing", &HybridHttpCurlSpec::doYourThing);
+      prototype.registerHybridMethod("doYourThingAsync", &HybridHttpCurlSpec::doYourThingAsync);
+      prototype.registerHybridMethod("setAuth", &HybridHttpCurlSpec::setAuth);
+      prototype.registerHybridMethod("toRawRequest", &HybridHttpCurlSpec::toRawRequest);
+      prototype.registerHybridMethod("getResponseSb", &HybridHttpCurlSpec::getResponseSb);
+      prototype.registerHybridMethod("getResponseBd", &HybridHttpCurlSpec::getResponseBd);
+      prototype.registerHybridMethod("getResponseJson", &HybridHttpCurlSpec::getResponseJson);
+      prototype.registerHybridMethod("getResponseXml", &HybridHttpCurlSpec::getResponseXml);
+      prototype.registerHybridMethod("getResponseJarr", &HybridHttpCurlSpec::getResponseJarr);
+      prototype.registerHybridMethod("setVar", &HybridHttpCurlSpec::setVar);
+      prototype.registerHybridMethod("addTargetOutput", &HybridHttpCurlSpec::addTargetOutput);
+      prototype.registerHybridMethod("clearVar", &HybridHttpCurlSpec::clearVar);
+      prototype.registerHybridMethod("getVar", &HybridHttpCurlSpec::getVar);
+      prototype.registerHybridMethod("addFunction", &HybridHttpCurlSpec::addFunction);
+      prototype.registerHybridMethod("addOutput", &HybridHttpCurlSpec::addOutput);
+      prototype.registerHybridMethod("examinePlan", &HybridHttpCurlSpec::examinePlan);
+      prototype.registerHybridMethod("getAllVars", &HybridHttpCurlSpec::getAllVars);
+      prototype.registerHybridMethod("clearTargetOutput", &HybridHttpCurlSpec::clearTargetOutput);
+      prototype.registerHybridMethod("varDefined", &HybridHttpCurlSpec::varDefined);
+      prototype.registerHybridMethod("addOutput2", &HybridHttpCurlSpec::addOutput2);
+      prototype.registerHybridMethod("abort", &HybridHttpCurlSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridHttpCurlSpec.hpp

@@ -0,0 +1,125 @@
+///
+/// HybridHttpCurlSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridXmlSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridXmlSpec; }
+// Forward declaration of `HybridJsonArraySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonArraySpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridJsonObjectSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridXmlSpec.hpp"
+#include "HybridJsonArraySpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `HttpCurl`
+   * Inherit this class to create instances of `HybridHttpCurlSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridHttpCurl: public HybridHttpCurlSpec {
+   * public:
+   *   HybridHttpCurl(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridHttpCurlSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridHttpCurlSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridHttpCurlSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual double getStatusCode() = 0;
+      virtual std::string getResponseBodyStr() = 0;
+      virtual std::string getResponseFilePath() = 0;
+      virtual void setResponseFilePath(const std::string& responseFilePath) = 0;
+      virtual bool getEnableBodyVars() = 0;
+      virtual void setEnableBodyVars(bool enableBodyVars) = 0;
+      virtual double getFailReason() = 0;
+      virtual std::string getFailedCurl() = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+      virtual std::optional<std::function<void(double /* pctDone */)>> getOnPercentDone() = 0;
+      virtual void setOnPercentDone(const std::optional<std::function<void(double /* pctDone */)>>& onPercentDone) = 0;
+      virtual std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>> getOnProgressInfo() = 0;
+      virtual void setOnProgressInfo(const std::optional<std::function<void(const std::string& /* name */, const std::string& /* value */)>>& onProgressInfo) = 0;
+
+    public:
+      // Methods
+      virtual void doYourThing(const std::string& targetCurl) = 0;
+      virtual std::shared_ptr<Promise<void>> doYourThingAsync(const std::string& targetCurl) = 0;
+      virtual void setAuth(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void toRawRequest(const std::string& curlCommand, const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void getResponseSb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void getResponseBd(const std::shared_ptr<HybridBinDataSpec>& bd) = 0;
+      virtual void getResponseJson(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void getResponseXml(const std::shared_ptr<HybridXmlSpec>& xml) = 0;
+      virtual void getResponseJarr(const std::shared_ptr<HybridJsonArraySpec>& jarr) = 0;
+      virtual void setVar(const std::string& varName, const std::string& varValue) = 0;
+      virtual void addTargetOutput(const std::string& jsonPath, const std::string& varName) = 0;
+      virtual void clearVar(const std::string& varName) = 0;
+      virtual std::string getVar(const std::string& varName) = 0;
+      virtual void addFunction(const std::string& funcName, const std::string& curl) = 0;
+      virtual void addOutput(const std::string& funcName, const std::string& jsonPath, const std::string& varName) = 0;
+      virtual void examinePlan(const std::string& curl, const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void getAllVars(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void clearTargetOutput(const std::string& varName) = 0;
+      virtual bool varDefined(const std::string& varName) = 0;
+      virtual void addOutput2(const std::string& funcName, const std::string& arrayPath, const std::string& wherePath, const std::string& whereValue, bool caseSensitive, const std::string& subPath, const std::string& varName) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "HttpCurl";
+  };
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridHttpRequestSpec.cpp

@@ -0,0 +1,76 @@
+///
+/// HybridHttpRequestSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridHttpRequestSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridHttpRequestSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridHttpRequestSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridHttpRequestSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridHttpRequestSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridHttpRequestSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridHttpRequestSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridHttpRequestSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridHttpRequestSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridHttpRequestSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridHttpRequestSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridHttpRequestSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("boundary", &HybridHttpRequestSpec::getBoundary);
+      prototype.registerHybridSetter("boundary", &HybridHttpRequestSpec::setBoundary);
+      prototype.registerHybridGetter("charset", &HybridHttpRequestSpec::getCharset);
+      prototype.registerHybridSetter("charset", &HybridHttpRequestSpec::setCharset);
+      prototype.registerHybridGetter("contentType", &HybridHttpRequestSpec::getContentType);
+      prototype.registerHybridSetter("contentType", &HybridHttpRequestSpec::setContentType);
+      prototype.registerHybridGetter("entireHeader", &HybridHttpRequestSpec::getEntireHeader);
+      prototype.registerHybridSetter("entireHeader", &HybridHttpRequestSpec::setEntireHeader);
+      prototype.registerHybridGetter("httpVerb", &HybridHttpRequestSpec::getHttpVerb);
+      prototype.registerHybridSetter("httpVerb", &HybridHttpRequestSpec::setHttpVerb);
+      prototype.registerHybridGetter("httpVersion", &HybridHttpRequestSpec::getHttpVersion);
+      prototype.registerHybridSetter("httpVersion", &HybridHttpRequestSpec::setHttpVersion);
+      prototype.registerHybridGetter("numHeaderFields", &HybridHttpRequestSpec::getNumHeaderFields);
+      prototype.registerHybridGetter("numParams", &HybridHttpRequestSpec::getNumParams);
+      prototype.registerHybridGetter("path", &HybridHttpRequestSpec::getPath);
+      prototype.registerHybridSetter("path", &HybridHttpRequestSpec::setPath);
+      prototype.registerHybridGetter("sendCharset", &HybridHttpRequestSpec::getSendCharset);
+      prototype.registerHybridSetter("sendCharset", &HybridHttpRequestSpec::setSendCharset);
+      prototype.registerHybridMethod("addFileForUpload", &HybridHttpRequestSpec::addFileForUpload);
+      prototype.registerHybridMethod("addFileForUpload2", &HybridHttpRequestSpec::addFileForUpload2);
+      prototype.registerHybridMethod("addHeader", &HybridHttpRequestSpec::addHeader);
+      prototype.registerHybridMethod("addParam", &HybridHttpRequestSpec::addParam);
+      prototype.registerHybridMethod("addStringForUpload", &HybridHttpRequestSpec::addStringForUpload);
+      prototype.registerHybridMethod("addStringForUpload2", &HybridHttpRequestSpec::addStringForUpload2);
+      prototype.registerHybridMethod("addSubHeader", &HybridHttpRequestSpec::addSubHeader);
+      prototype.registerHybridMethod("generateRequestText", &HybridHttpRequestSpec::generateRequestText);
+      prototype.registerHybridMethod("getHeaderField", &HybridHttpRequestSpec::getHeaderField);
+      prototype.registerHybridMethod("getHeaderName", &HybridHttpRequestSpec::getHeaderName);
+      prototype.registerHybridMethod("getHeaderValue", &HybridHttpRequestSpec::getHeaderValue);
+      prototype.registerHybridMethod("getParam", &HybridHttpRequestSpec::getParam);
+      prototype.registerHybridMethod("getParamName", &HybridHttpRequestSpec::getParamName);
+      prototype.registerHybridMethod("getParamValue", &HybridHttpRequestSpec::getParamValue);
+      prototype.registerHybridMethod("getUrlEncodedParams", &HybridHttpRequestSpec::getUrlEncodedParams);
+      prototype.registerHybridMethod("loadBodyFromFile", &HybridHttpRequestSpec::loadBodyFromFile);
+      prototype.registerHybridMethod("loadBodyFromString", &HybridHttpRequestSpec::loadBodyFromString);
+      prototype.registerHybridMethod("removeAllParams", &HybridHttpRequestSpec::removeAllParams);
+      prototype.registerHybridMethod("removeHeader", &HybridHttpRequestSpec::removeHeader);
+      prototype.registerHybridMethod("removeParam", &HybridHttpRequestSpec::removeParam);
+      prototype.registerHybridMethod("setFromUrl", &HybridHttpRequestSpec::setFromUrl);
+      prototype.registerHybridMethod("streamBodyFromFile", &HybridHttpRequestSpec::streamBodyFromFile);
+      prototype.registerHybridMethod("streamChunkFromFile", &HybridHttpRequestSpec::streamChunkFromFile);
+      prototype.registerHybridMethod("generateRequestFile", &HybridHttpRequestSpec::generateRequestFile);
+      prototype.registerHybridMethod("addMwsSignature", &HybridHttpRequestSpec::addMwsSignature);
+      prototype.registerHybridMethod("loadBodyFromBd", &HybridHttpRequestSpec::loadBodyFromBd);
+      prototype.registerHybridMethod("loadBodyFromSb", &HybridHttpRequestSpec::loadBodyFromSb);
+      prototype.registerHybridMethod("addBdForUpload", &HybridHttpRequestSpec::addBdForUpload);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridHttpRequestSpec.hpp

@@ -0,0 +1,122 @@
+///
+/// HybridHttpRequestSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridBinDataSpec.hpp"
+#include "HybridStringBuilderSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `HttpRequest`
+   * Inherit this class to create instances of `HybridHttpRequestSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridHttpRequest: public HybridHttpRequestSpec {
+   * public:
+   *   HybridHttpRequest(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridHttpRequestSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridHttpRequestSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridHttpRequestSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual std::string getBoundary() = 0;
+      virtual void setBoundary(const std::string& boundary) = 0;
+      virtual std::string getCharset() = 0;
+      virtual void setCharset(const std::string& charset) = 0;
+      virtual std::string getContentType() = 0;
+      virtual void setContentType(const std::string& contentType) = 0;
+      virtual std::string getEntireHeader() = 0;
+      virtual void setEntireHeader(const std::string& entireHeader) = 0;
+      virtual std::string getHttpVerb() = 0;
+      virtual void setHttpVerb(const std::string& httpVerb) = 0;
+      virtual std::string getHttpVersion() = 0;
+      virtual void setHttpVersion(const std::string& httpVersion) = 0;
+      virtual double getNumHeaderFields() = 0;
+      virtual double getNumParams() = 0;
+      virtual std::string getPath() = 0;
+      virtual void setPath(const std::string& path) = 0;
+      virtual bool getSendCharset() = 0;
+      virtual void setSendCharset(bool sendCharset) = 0;
+
+    public:
+      // Methods
+      virtual void addFileForUpload(const std::string& name, const std::string& filePath) = 0;
+      virtual void addFileForUpload2(const std::string& name, const std::string& filePath, const std::string& contentType) = 0;
+      virtual void addHeader(const std::string& name, const std::string& value) = 0;
+      virtual void addParam(const std::string& name, const std::string& value) = 0;
+      virtual void addStringForUpload(const std::string& name, const std::string& filename, const std::string& strData, const std::string& charset) = 0;
+      virtual void addStringForUpload2(const std::string& name, const std::string& filename, const std::string& strData, const std::string& charset, const std::string& contentType) = 0;
+      virtual void addSubHeader(double index, const std::string& name, const std::string& value) = 0;
+      virtual std::string generateRequestText() = 0;
+      virtual std::string getHeaderField(const std::string& name) = 0;
+      virtual std::string getHeaderName(double index) = 0;
+      virtual std::string getHeaderValue(double index) = 0;
+      virtual std::string getParam(const std::string& name) = 0;
+      virtual std::string getParamName(double index) = 0;
+      virtual std::string getParamValue(double index) = 0;
+      virtual std::string getUrlEncodedParams() = 0;
+      virtual void loadBodyFromFile(const std::string& filePath) = 0;
+      virtual void loadBodyFromString(const std::string& bodyStr, const std::string& charset) = 0;
+      virtual void removeAllParams() = 0;
+      virtual void removeHeader(const std::string& name) = 0;
+      virtual void removeParam(const std::string& name) = 0;
+      virtual void setFromUrl(const std::string& url) = 0;
+      virtual void streamBodyFromFile(const std::string& filePath) = 0;
+      virtual void streamChunkFromFile(const std::string& path, const std::string& offset, const std::string& numBytes) = 0;
+      virtual void generateRequestFile(const std::string& path) = 0;
+      virtual void addMwsSignature(const std::string& domain, const std::string& mwsSecretKey) = 0;
+      virtual void loadBodyFromBd(const std::shared_ptr<HybridBinDataSpec>& requestBody) = 0;
+      virtual void loadBodyFromSb(const std::shared_ptr<HybridStringBuilderSpec>& requestBody, const std::string& charset) = 0;
+      virtual void addBdForUpload(const std::string& name, const std::string& remoteFilename, const std::shared_ptr<HybridBinDataSpec>& byteData, const std::string& contentType) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "HttpRequest";
+  };
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridHttpResponseSpec.cpp

@@ -0,0 +1,64 @@
+///
+/// HybridHttpResponseSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridHttpResponseSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridHttpResponseSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridHttpResponseSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridHttpResponseSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridHttpResponseSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridHttpResponseSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridHttpResponseSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridHttpResponseSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridHttpResponseSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridHttpResponseSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridHttpResponseSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridHttpResponseSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("bodyQP", &HybridHttpResponseSpec::getBodyQP);
+      prototype.registerHybridGetter("bodyStr", &HybridHttpResponseSpec::getBodyStr);
+      prototype.registerHybridGetter("charset", &HybridHttpResponseSpec::getCharset);
+      prototype.registerHybridGetter("contentLength", &HybridHttpResponseSpec::getContentLength);
+      prototype.registerHybridGetter("contentLength64", &HybridHttpResponseSpec::getContentLength64);
+      prototype.registerHybridGetter("dateStr", &HybridHttpResponseSpec::getDateStr);
+      prototype.registerHybridGetter("domain", &HybridHttpResponseSpec::getDomain);
+      prototype.registerHybridGetter("finalRedirectUrl", &HybridHttpResponseSpec::getFinalRedirectUrl);
+      prototype.registerHybridGetter("fullMime", &HybridHttpResponseSpec::getFullMime);
+      prototype.registerHybridGetter("header", &HybridHttpResponseSpec::getHeader);
+      prototype.registerHybridGetter("numCookies", &HybridHttpResponseSpec::getNumCookies);
+      prototype.registerHybridGetter("numHeaderFields", &HybridHttpResponseSpec::getNumHeaderFields);
+      prototype.registerHybridGetter("statusCode", &HybridHttpResponseSpec::getStatusCode);
+      prototype.registerHybridGetter("statusLine", &HybridHttpResponseSpec::getStatusLine);
+      prototype.registerHybridGetter("statusText", &HybridHttpResponseSpec::getStatusText);
+      prototype.registerHybridGetter("uncommonOptions", &HybridHttpResponseSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridHttpResponseSpec::setUncommonOptions);
+      prototype.registerHybridMethod("getCookieDomain", &HybridHttpResponseSpec::getCookieDomain);
+      prototype.registerHybridMethod("getCookieExpiresStr", &HybridHttpResponseSpec::getCookieExpiresStr);
+      prototype.registerHybridMethod("getCookieName", &HybridHttpResponseSpec::getCookieName);
+      prototype.registerHybridMethod("getCookiePath", &HybridHttpResponseSpec::getCookiePath);
+      prototype.registerHybridMethod("getCookieValue", &HybridHttpResponseSpec::getCookieValue);
+      prototype.registerHybridMethod("getHeaderField", &HybridHttpResponseSpec::getHeaderField);
+      prototype.registerHybridMethod("getHeaderFieldAttr", &HybridHttpResponseSpec::getHeaderFieldAttr);
+      prototype.registerHybridMethod("getHeaderName", &HybridHttpResponseSpec::getHeaderName);
+      prototype.registerHybridMethod("getHeaderValue", &HybridHttpResponseSpec::getHeaderValue);
+      prototype.registerHybridMethod("saveBodyBinary", &HybridHttpResponseSpec::saveBodyBinary);
+      prototype.registerHybridMethod("saveBodyText", &HybridHttpResponseSpec::saveBodyText);
+      prototype.registerHybridMethod("urlEncParamValue", &HybridHttpResponseSpec::urlEncParamValue);
+      prototype.registerHybridMethod("getBodySb", &HybridHttpResponseSpec::getBodySb);
+      prototype.registerHybridMethod("getBodyBd", &HybridHttpResponseSpec::getBodyBd);
+      prototype.registerHybridMethod("getBodyJson", &HybridHttpResponseSpec::getBodyJson);
+      prototype.registerHybridMethod("getBodyJarr", &HybridHttpResponseSpec::getBodyJarr);
+      prototype.registerHybridMethod("getBodyXml", &HybridHttpResponseSpec::getBodyXml);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

package/nitrogen/generated/shared/c++/HybridHttpResponseSpec.hpp

@@ -0,0 +1,119 @@
+///
+/// HybridHttpResponseSpec.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#if __has_include(<NitroModules/HybridObject.hpp>)
+#include <NitroModules/HybridObject.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `HybridStringBuilderSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridStringBuilderSpec; }
+// Forward declaration of `HybridBinDataSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridBinDataSpec; }
+// Forward declaration of `HybridJsonObjectSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonObjectSpec; }
+// Forward declaration of `HybridJsonArraySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJsonArraySpec; }
+// Forward declaration of `HybridXmlSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridXmlSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridStringBuilderSpec.hpp"
+#include "HybridBinDataSpec.hpp"
+#include "HybridJsonObjectSpec.hpp"
+#include "HybridJsonArraySpec.hpp"
+#include "HybridXmlSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `HttpResponse`
+   * Inherit this class to create instances of `HybridHttpResponseSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridHttpResponse: public HybridHttpResponseSpec {
+   * public:
+   *   HybridHttpResponse(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridHttpResponseSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridHttpResponseSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridHttpResponseSpec() override = default;
+
+    public:
+      // Properties
+      virtual std::string getLastErrorHtml() = 0;
+      virtual std::string getLastErrorText() = 0;
+      virtual std::string getLastErrorXml() = 0;
+      virtual std::string getVersion() = 0;
+      virtual std::string getDebugLogFilePath() = 0;
+      virtual void setDebugLogFilePath(const std::string& debugLogFilePath) = 0;
+      virtual bool getVerboseLogging() = 0;
+      virtual void setVerboseLogging(bool verboseLogging) = 0;
+      virtual bool getLastMethodSuccess() = 0;
+      virtual void setLastMethodSuccess(bool lastMethodSuccess) = 0;
+      virtual std::string getBodyQP() = 0;
+      virtual std::string getBodyStr() = 0;
+      virtual std::string getCharset() = 0;
+      virtual double getContentLength() = 0;
+      virtual double getContentLength64() = 0;
+      virtual std::string getDateStr() = 0;
+      virtual std::string getDomain() = 0;
+      virtual std::string getFinalRedirectUrl() = 0;
+      virtual std::string getFullMime() = 0;
+      virtual std::string getHeader() = 0;
+      virtual double getNumCookies() = 0;
+      virtual double getNumHeaderFields() = 0;
+      virtual double getStatusCode() = 0;
+      virtual std::string getStatusLine() = 0;
+      virtual std::string getStatusText() = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+
+    public:
+      // Methods
+      virtual std::string getCookieDomain(double index) = 0;
+      virtual std::string getCookieExpiresStr(double index) = 0;
+      virtual std::string getCookieName(double index) = 0;
+      virtual std::string getCookiePath(double index) = 0;
+      virtual std::string getCookieValue(double index) = 0;
+      virtual std::string getHeaderField(const std::string& fieldName) = 0;
+      virtual std::string getHeaderFieldAttr(const std::string& fieldName, const std::string& attrName) = 0;
+      virtual std::string getHeaderName(double index) = 0;
+      virtual std::string getHeaderValue(double index) = 0;
+      virtual void saveBodyBinary(const std::string& path) = 0;
+      virtual void saveBodyText(bool bCrlf, const std::string& path) = 0;
+      virtual std::string urlEncParamValue(const std::string& encodedParamString, const std::string& paramName) = 0;
+      virtual void getBodySb(const std::shared_ptr<HybridStringBuilderSpec>& sb) = 0;
+      virtual void getBodyBd(const std::shared_ptr<HybridBinDataSpec>& binData) = 0;
+      virtual void getBodyJson(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void getBodyJarr(const std::shared_ptr<HybridJsonArraySpec>& jarr) = 0;
+      virtual void getBodyXml(const std::shared_ptr<HybridXmlSpec>& xml) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "HttpResponse";
+  };
+
+} // namespace margelo::nitro::chilkat