@chilkat/react-native 11.6.1

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

@@ -0,0 +1,97 @@
+///
+/// HybridTrustedRootsSpec.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 `HybridCertSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCertSpec; }
+// Forward declaration of `HybridJavaKeyStoreSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridJavaKeyStoreSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <memory>
+#include "HybridCertSpec.hpp"
+#include "HybridJavaKeyStoreSpec.hpp"
+#include <NitroModules/Promise.hpp>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `TrustedRoots`
+   * Inherit this class to create instances of `HybridTrustedRootsSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridTrustedRoots: public HybridTrustedRootsSpec {
+   * public:
+   *   HybridTrustedRoots(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridTrustedRootsSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridTrustedRootsSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridTrustedRootsSpec() 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 getNumCerts() = 0;
+      virtual bool getTrustSystemCaRoots() = 0;
+      virtual void setTrustSystemCaRoots(bool trustSystemCaRoots) = 0;
+      virtual bool getRejectSelfSignedCerts() = 0;
+      virtual void setRejectSelfSignedCerts(bool rejectSelfSignedCerts) = 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 activate() = 0;
+      virtual void addCert(const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void addJavaKeyStore(const std::shared_ptr<HybridJavaKeyStoreSpec>& keystore) = 0;
+      virtual std::shared_ptr<Promise<void>> addJavaKeyStoreAsync(const std::shared_ptr<HybridJavaKeyStoreSpec>& keystore) = 0;
+      virtual void deactivate() = 0;
+      virtual void loadCaCertsPem(const std::string& path) = 0;
+      virtual std::shared_ptr<Promise<void>> loadCaCertsPemAsync(const std::string& path) = 0;
+      virtual void certAt(double index, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "TrustedRoots";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,48 @@
+///
+/// HybridUnixCompressSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridUnixCompressSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridUnixCompressSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridUnixCompressSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridUnixCompressSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridUnixCompressSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridUnixCompressSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridUnixCompressSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridUnixCompressSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridUnixCompressSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridUnixCompressSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridUnixCompressSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridUnixCompressSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("heartbeatMs", &HybridUnixCompressSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridUnixCompressSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("abortCurrent", &HybridUnixCompressSpec::getAbortCurrent);
+      prototype.registerHybridSetter("abortCurrent", &HybridUnixCompressSpec::setAbortCurrent);
+      prototype.registerHybridGetter("onPercentDone", &HybridUnixCompressSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridUnixCompressSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridUnixCompressSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridUnixCompressSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("compressFile", &HybridUnixCompressSpec::compressFile);
+      prototype.registerHybridMethod("compressFileAsync", &HybridUnixCompressSpec::compressFileAsync);
+      prototype.registerHybridMethod("compressStringToFile", &HybridUnixCompressSpec::compressStringToFile);
+      prototype.registerHybridMethod("unTarZ", &HybridUnixCompressSpec::unTarZ);
+      prototype.registerHybridMethod("unTarZAsync", &HybridUnixCompressSpec::unTarZAsync);
+      prototype.registerHybridMethod("uncompressFile", &HybridUnixCompressSpec::uncompressFile);
+      prototype.registerHybridMethod("uncompressFileAsync", &HybridUnixCompressSpec::uncompressFileAsync);
+      prototype.registerHybridMethod("uncompressFileToString", &HybridUnixCompressSpec::uncompressFileToString);
+      prototype.registerHybridMethod("uncompressFileToStringAsync", &HybridUnixCompressSpec::uncompressFileToStringAsync);
+      prototype.registerHybridMethod("abort", &HybridUnixCompressSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,91 @@
+///
+/// HybridUnixCompressSpec.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
+
+
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `UnixCompress`
+   * Inherit this class to create instances of `HybridUnixCompressSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridUnixCompress: public HybridUnixCompressSpec {
+   * public:
+   *   HybridUnixCompress(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridUnixCompressSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridUnixCompressSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridUnixCompressSpec() 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 getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual bool getAbortCurrent() = 0;
+      virtual void setAbortCurrent(bool abortCurrent) = 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 compressFile(const std::string& inFilename, const std::string& destPath) = 0;
+      virtual std::shared_ptr<Promise<void>> compressFileAsync(const std::string& inFilename, const std::string& destPath) = 0;
+      virtual void compressStringToFile(const std::string& inStr, const std::string& charset, const std::string& destPath) = 0;
+      virtual void unTarZ(const std::string& zFilename, const std::string& destDir, bool bNoAbsolute) = 0;
+      virtual std::shared_ptr<Promise<void>> unTarZAsync(const std::string& zFilename, const std::string& destDir, bool bNoAbsolute) = 0;
+      virtual void uncompressFile(const std::string& inFilename, const std::string& destPath) = 0;
+      virtual std::shared_ptr<Promise<void>> uncompressFileAsync(const std::string& inFilename, const std::string& destPath) = 0;
+      virtual std::string uncompressFileToString(const std::string& zFilename, const std::string& charset) = 0;
+      virtual std::shared_ptr<Promise<std::string>> uncompressFileToStringAsync(const std::string& zFilename, const std::string& charset) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "UnixCompress";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,98 @@
+///
+/// HybridUploadSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridUploadSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridUploadSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridUploadSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridUploadSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridUploadSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridUploadSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridUploadSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridUploadSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridUploadSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridUploadSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridUploadSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridUploadSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("bandwidthThrottleUp", &HybridUploadSpec::getBandwidthThrottleUp);
+      prototype.registerHybridSetter("bandwidthThrottleUp", &HybridUploadSpec::setBandwidthThrottleUp);
+      prototype.registerHybridGetter("chunkSize", &HybridUploadSpec::getChunkSize);
+      prototype.registerHybridSetter("chunkSize", &HybridUploadSpec::setChunkSize);
+      prototype.registerHybridGetter("clientIpAddress", &HybridUploadSpec::getClientIpAddress);
+      prototype.registerHybridSetter("clientIpAddress", &HybridUploadSpec::setClientIpAddress);
+      prototype.registerHybridGetter("expect100Continue", &HybridUploadSpec::getExpect100Continue);
+      prototype.registerHybridSetter("expect100Continue", &HybridUploadSpec::setExpect100Continue);
+      prototype.registerHybridGetter("heartbeatMs", &HybridUploadSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridUploadSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("hostname", &HybridUploadSpec::getHostname);
+      prototype.registerHybridSetter("hostname", &HybridUploadSpec::setHostname);
+      prototype.registerHybridGetter("idleTimeoutMs", &HybridUploadSpec::getIdleTimeoutMs);
+      prototype.registerHybridSetter("idleTimeoutMs", &HybridUploadSpec::setIdleTimeoutMs);
+      prototype.registerHybridGetter("login", &HybridUploadSpec::getLogin);
+      prototype.registerHybridSetter("login", &HybridUploadSpec::setLogin);
+      prototype.registerHybridGetter("numBytesSent", &HybridUploadSpec::getNumBytesSent);
+      prototype.registerHybridGetter("password", &HybridUploadSpec::getPassword);
+      prototype.registerHybridSetter("password", &HybridUploadSpec::setPassword);
+      prototype.registerHybridGetter("path", &HybridUploadSpec::getPath);
+      prototype.registerHybridSetter("path", &HybridUploadSpec::setPath);
+      prototype.registerHybridGetter("percentDoneScale", &HybridUploadSpec::getPercentDoneScale);
+      prototype.registerHybridSetter("percentDoneScale", &HybridUploadSpec::setPercentDoneScale);
+      prototype.registerHybridGetter("percentUploaded", &HybridUploadSpec::getPercentUploaded);
+      prototype.registerHybridGetter("port", &HybridUploadSpec::getPort);
+      prototype.registerHybridSetter("port", &HybridUploadSpec::setPort);
+      prototype.registerHybridGetter("preferIpv6", &HybridUploadSpec::getPreferIpv6);
+      prototype.registerHybridSetter("preferIpv6", &HybridUploadSpec::setPreferIpv6);
+      prototype.registerHybridGetter("proxyDomain", &HybridUploadSpec::getProxyDomain);
+      prototype.registerHybridSetter("proxyDomain", &HybridUploadSpec::setProxyDomain);
+      prototype.registerHybridGetter("proxyLogin", &HybridUploadSpec::getProxyLogin);
+      prototype.registerHybridSetter("proxyLogin", &HybridUploadSpec::setProxyLogin);
+      prototype.registerHybridGetter("proxyPassword", &HybridUploadSpec::getProxyPassword);
+      prototype.registerHybridSetter("proxyPassword", &HybridUploadSpec::setProxyPassword);
+      prototype.registerHybridGetter("proxyPort", &HybridUploadSpec::getProxyPort);
+      prototype.registerHybridSetter("proxyPort", &HybridUploadSpec::setProxyPort);
+      prototype.registerHybridGetter("responseHeader", &HybridUploadSpec::getResponseHeader);
+      prototype.registerHybridGetter("responseStatus", &HybridUploadSpec::getResponseStatus);
+      prototype.registerHybridGetter("ssl", &HybridUploadSpec::getSsl);
+      prototype.registerHybridSetter("ssl", &HybridUploadSpec::setSsl);
+      prototype.registerHybridGetter("totalUploadSize", &HybridUploadSpec::getTotalUploadSize);
+      prototype.registerHybridGetter("uploadInProgress", &HybridUploadSpec::getUploadInProgress);
+      prototype.registerHybridGetter("uploadSuccess", &HybridUploadSpec::getUploadSuccess);
+      prototype.registerHybridGetter("tlsPinSet", &HybridUploadSpec::getTlsPinSet);
+      prototype.registerHybridSetter("tlsPinSet", &HybridUploadSpec::setTlsPinSet);
+      prototype.registerHybridGetter("sslAllowedCiphers", &HybridUploadSpec::getSslAllowedCiphers);
+      prototype.registerHybridSetter("sslAllowedCiphers", &HybridUploadSpec::setSslAllowedCiphers);
+      prototype.registerHybridGetter("sslProtocol", &HybridUploadSpec::getSslProtocol);
+      prototype.registerHybridSetter("sslProtocol", &HybridUploadSpec::setSslProtocol);
+      prototype.registerHybridGetter("abortCurrent", &HybridUploadSpec::getAbortCurrent);
+      prototype.registerHybridSetter("abortCurrent", &HybridUploadSpec::setAbortCurrent);
+      prototype.registerHybridGetter("responseBodyStr", &HybridUploadSpec::getResponseBodyStr);
+      prototype.registerHybridGetter("currentFilename", &HybridUploadSpec::getCurrentFilename);
+      prototype.registerHybridGetter("onPercentDone", &HybridUploadSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridUploadSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridUploadSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridUploadSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("abortUpload", &HybridUploadSpec::abortUpload);
+      prototype.registerHybridMethod("addCustomHeader", &HybridUploadSpec::addCustomHeader);
+      prototype.registerHybridMethod("addFileReference", &HybridUploadSpec::addFileReference);
+      prototype.registerHybridMethod("addParam", &HybridUploadSpec::addParam);
+      prototype.registerHybridMethod("beginUpload", &HybridUploadSpec::beginUpload);
+      prototype.registerHybridMethod("blockingUpload", &HybridUploadSpec::blockingUpload);
+      prototype.registerHybridMethod("blockingUploadAsync", &HybridUploadSpec::blockingUploadAsync);
+      prototype.registerHybridMethod("clearFileReferences", &HybridUploadSpec::clearFileReferences);
+      prototype.registerHybridMethod("clearParams", &HybridUploadSpec::clearParams);
+      prototype.registerHybridMethod("sleepMs", &HybridUploadSpec::sleepMs);
+      prototype.registerHybridMethod("abort", &HybridUploadSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,141 @@
+///
+/// HybridUploadSpec.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
+
+
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Upload`
+   * Inherit this class to create instances of `HybridUploadSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridUpload: public HybridUploadSpec {
+   * public:
+   *   HybridUpload(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridUploadSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridUploadSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridUploadSpec() 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 getBandwidthThrottleUp() = 0;
+      virtual void setBandwidthThrottleUp(double bandwidthThrottleUp) = 0;
+      virtual double getChunkSize() = 0;
+      virtual void setChunkSize(double chunkSize) = 0;
+      virtual std::string getClientIpAddress() = 0;
+      virtual void setClientIpAddress(const std::string& clientIpAddress) = 0;
+      virtual bool getExpect100Continue() = 0;
+      virtual void setExpect100Continue(bool expect100Continue) = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual std::string getHostname() = 0;
+      virtual void setHostname(const std::string& hostname) = 0;
+      virtual double getIdleTimeoutMs() = 0;
+      virtual void setIdleTimeoutMs(double idleTimeoutMs) = 0;
+      virtual std::string getLogin() = 0;
+      virtual void setLogin(const std::string& login) = 0;
+      virtual double getNumBytesSent() = 0;
+      virtual std::string getPassword() = 0;
+      virtual void setPassword(const std::string& password) = 0;
+      virtual std::string getPath() = 0;
+      virtual void setPath(const std::string& path) = 0;
+      virtual double getPercentDoneScale() = 0;
+      virtual void setPercentDoneScale(double percentDoneScale) = 0;
+      virtual double getPercentUploaded() = 0;
+      virtual double getPort() = 0;
+      virtual void setPort(double port) = 0;
+      virtual bool getPreferIpv6() = 0;
+      virtual void setPreferIpv6(bool preferIpv6) = 0;
+      virtual std::string getProxyDomain() = 0;
+      virtual void setProxyDomain(const std::string& proxyDomain) = 0;
+      virtual std::string getProxyLogin() = 0;
+      virtual void setProxyLogin(const std::string& proxyLogin) = 0;
+      virtual std::string getProxyPassword() = 0;
+      virtual void setProxyPassword(const std::string& proxyPassword) = 0;
+      virtual double getProxyPort() = 0;
+      virtual void setProxyPort(double proxyPort) = 0;
+      virtual std::string getResponseHeader() = 0;
+      virtual double getResponseStatus() = 0;
+      virtual bool getSsl() = 0;
+      virtual void setSsl(bool ssl) = 0;
+      virtual double getTotalUploadSize() = 0;
+      virtual bool getUploadInProgress() = 0;
+      virtual bool getUploadSuccess() = 0;
+      virtual std::string getTlsPinSet() = 0;
+      virtual void setTlsPinSet(const std::string& tlsPinSet) = 0;
+      virtual std::string getSslAllowedCiphers() = 0;
+      virtual void setSslAllowedCiphers(const std::string& sslAllowedCiphers) = 0;
+      virtual std::string getSslProtocol() = 0;
+      virtual void setSslProtocol(const std::string& sslProtocol) = 0;
+      virtual bool getAbortCurrent() = 0;
+      virtual void setAbortCurrent(bool abortCurrent) = 0;
+      virtual std::string getResponseBodyStr() = 0;
+      virtual std::string getCurrentFilename() = 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 abortUpload() = 0;
+      virtual void addCustomHeader(const std::string& name, const std::string& value) = 0;
+      virtual void addFileReference(const std::string& name, const std::string& filename) = 0;
+      virtual void addParam(const std::string& name, const std::string& value) = 0;
+      virtual void beginUpload() = 0;
+      virtual void blockingUpload() = 0;
+      virtual std::shared_ptr<Promise<void>> blockingUploadAsync() = 0;
+      virtual void clearFileReferences() = 0;
+      virtual void clearParams() = 0;
+      virtual void sleepMs(double millisec) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Upload";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,42 @@
+///
+/// HybridUrlSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridUrlSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridUrlSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridUrlSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridUrlSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridUrlSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridUrlSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridUrlSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridUrlSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridUrlSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridUrlSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridUrlSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridUrlSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("frag", &HybridUrlSpec::getFrag);
+      prototype.registerHybridGetter("host", &HybridUrlSpec::getHost);
+      prototype.registerHybridGetter("hostType", &HybridUrlSpec::getHostType);
+      prototype.registerHybridGetter("login", &HybridUrlSpec::getLogin);
+      prototype.registerHybridGetter("password", &HybridUrlSpec::getPassword);
+      prototype.registerHybridGetter("path", &HybridUrlSpec::getPath);
+      prototype.registerHybridGetter("port", &HybridUrlSpec::getPort);
+      prototype.registerHybridGetter("query", &HybridUrlSpec::getQuery);
+      prototype.registerHybridGetter("ssl", &HybridUrlSpec::getSsl);
+      prototype.registerHybridGetter("pathWithQueryParams", &HybridUrlSpec::getPathWithQueryParams);
+      prototype.registerHybridGetter("scheme", &HybridUrlSpec::getScheme);
+      prototype.registerHybridMethod("parseUrl", &HybridUrlSpec::parseUrl);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,82 @@
+///
+/// HybridUrlSpec.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
+
+
+
+#include <string>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Url`
+   * Inherit this class to create instances of `HybridUrlSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridUrl: public HybridUrlSpec {
+   * public:
+   *   HybridUrl(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridUrlSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridUrlSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridUrlSpec() 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 getFrag() = 0;
+      virtual std::string getHost() = 0;
+      virtual std::string getHostType() = 0;
+      virtual std::string getLogin() = 0;
+      virtual std::string getPassword() = 0;
+      virtual std::string getPath() = 0;
+      virtual double getPort() = 0;
+      virtual std::string getQuery() = 0;
+      virtual bool getSsl() = 0;
+      virtual std::string getPathWithQueryParams() = 0;
+      virtual std::string getScheme() = 0;
+
+    public:
+      // Methods
+      virtual void parseUrl(const std::string& url) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Url";
+  };
+
+} // namespace margelo::nitro::chilkat