@chilkat/react-native 11.6.1

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

@@ -0,0 +1,117 @@
+///
+/// HybridMcpSpec.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 `HybridSocketSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridSocketSpec; }
+
+#include <string>
+#include <functional>
+#include <optional>
+#include <NitroModules/Promise.hpp>
+#include <memory>
+#include "HybridJsonObjectSpec.hpp"
+#include "HybridSocketSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Mcp`
+   * Inherit this class to create instances of `HybridMcpSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridMcp: public HybridMcpSpec {
+   * public:
+   *   HybridMcp(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridMcpSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridMcpSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridMcpSpec() 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 getAuthToken() = 0;
+      virtual void setAuthToken(const std::string& authToken) = 0;
+      virtual std::string getSessionId() = 0;
+      virtual std::string getProtocolVersion() = 0;
+      virtual void setProtocolVersion(const std::string& protocolVersion) = 0;
+      virtual std::string getServerName() = 0;
+      virtual std::string getServerVersion() = 0;
+      virtual std::string getServerInstructions() = 0;
+      virtual bool getConnected() = 0;
+      virtual double getIdleTimeoutMs() = 0;
+      virtual void setIdleTimeoutMs(double idleTimeoutMs) = 0;
+      virtual double getConnectTimeoutMs() = 0;
+      virtual void setConnectTimeoutMs(double connectTimeoutMs) = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 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 connect(const std::string& url) = 0;
+      virtual std::shared_ptr<Promise<void>> connectAsync(const std::string& url) = 0;
+      virtual void close() = 0;
+      virtual std::shared_ptr<Promise<void>> closeAsync() = 0;
+      virtual void listTools(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual std::shared_ptr<Promise<void>> listToolsAsync(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void callTool(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) = 0;
+      virtual std::shared_ptr<Promise<void>> callToolAsync(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& resultJson) = 0;
+      virtual void listResources(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual std::shared_ptr<Promise<void>> listResourcesAsync(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void readResource(const std::string& uri, const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual std::shared_ptr<Promise<void>> readResourceAsync(const std::string& uri, const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void listPrompts(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual std::shared_ptr<Promise<void>> listPromptsAsync(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void getPrompt(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual std::shared_ptr<Promise<void>> getPromptAsync(const std::string& name, const std::shared_ptr<HybridJsonObjectSpec>& argsJson, const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void setConnectionSettings(const std::shared_ptr<HybridSocketSpec>& sock) = 0;
+      virtual void getLastJsonData(const std::shared_ptr<HybridJsonObjectSpec>& json) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Mcp";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,41 @@
+///
+/// HybridMessageSetSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridMessageSetSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridMessageSetSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridMessageSetSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridMessageSetSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridMessageSetSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridMessageSetSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridMessageSetSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridMessageSetSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridMessageSetSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridMessageSetSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridMessageSetSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridMessageSetSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("count", &HybridMessageSetSpec::getCount);
+      prototype.registerHybridGetter("hasUids", &HybridMessageSetSpec::getHasUids);
+      prototype.registerHybridSetter("hasUids", &HybridMessageSetSpec::setHasUids);
+      prototype.registerHybridMethod("containsId", &HybridMessageSetSpec::containsId);
+      prototype.registerHybridMethod("fromCompactString", &HybridMessageSetSpec::fromCompactString);
+      prototype.registerHybridMethod("getId", &HybridMessageSetSpec::getId);
+      prototype.registerHybridMethod("insertId", &HybridMessageSetSpec::insertId);
+      prototype.registerHybridMethod("removeId", &HybridMessageSetSpec::removeId);
+      prototype.registerHybridMethod("toCommaSeparatedStr", &HybridMessageSetSpec::toCommaSeparatedStr);
+      prototype.registerHybridMethod("toCompactString", &HybridMessageSetSpec::toCompactString);
+      prototype.registerHybridMethod("subtract", &HybridMessageSetSpec::subtract);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,84 @@
+///
+/// HybridMessageSetSpec.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 `HybridMessageSetSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridMessageSetSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridMessageSetSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `MessageSet`
+   * Inherit this class to create instances of `HybridMessageSetSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridMessageSet: public HybridMessageSetSpec {
+   * public:
+   *   HybridMessageSet(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridMessageSetSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridMessageSetSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridMessageSetSpec() 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 getCount() = 0;
+      virtual bool getHasUids() = 0;
+      virtual void setHasUids(bool hasUids) = 0;
+
+    public:
+      // Methods
+      virtual bool containsId(double msgId) = 0;
+      virtual void fromCompactString(const std::string& str) = 0;
+      virtual double getId(double index) = 0;
+      virtual void insertId(double id) = 0;
+      virtual void removeId(double id) = 0;
+      virtual std::string toCommaSeparatedStr() = 0;
+      virtual std::string toCompactString() = 0;
+      virtual void subtract(const std::shared_ptr<HybridMessageSetSpec>& msgSet) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "MessageSet";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,138 @@
+///
+/// HybridMhtSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridMhtSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridMhtSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridMhtSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridMhtSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridMhtSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridMhtSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridMhtSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridMhtSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridMhtSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridMhtSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridMhtSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridMhtSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("baseUrl", &HybridMhtSpec::getBaseUrl);
+      prototype.registerHybridSetter("baseUrl", &HybridMhtSpec::setBaseUrl);
+      prototype.registerHybridGetter("connectTimeout", &HybridMhtSpec::getConnectTimeout);
+      prototype.registerHybridSetter("connectTimeout", &HybridMhtSpec::setConnectTimeout);
+      prototype.registerHybridGetter("debugHtmlAfter", &HybridMhtSpec::getDebugHtmlAfter);
+      prototype.registerHybridSetter("debugHtmlAfter", &HybridMhtSpec::setDebugHtmlAfter);
+      prototype.registerHybridGetter("debugHtmlBefore", &HybridMhtSpec::getDebugHtmlBefore);
+      prototype.registerHybridSetter("debugHtmlBefore", &HybridMhtSpec::setDebugHtmlBefore);
+      prototype.registerHybridGetter("embedImages", &HybridMhtSpec::getEmbedImages);
+      prototype.registerHybridSetter("embedImages", &HybridMhtSpec::setEmbedImages);
+      prototype.registerHybridGetter("embedLocalOnly", &HybridMhtSpec::getEmbedLocalOnly);
+      prototype.registerHybridSetter("embedLocalOnly", &HybridMhtSpec::setEmbedLocalOnly);
+      prototype.registerHybridGetter("fetchFromCache", &HybridMhtSpec::getFetchFromCache);
+      prototype.registerHybridSetter("fetchFromCache", &HybridMhtSpec::setFetchFromCache);
+      prototype.registerHybridGetter("heartbeatMs", &HybridMhtSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridMhtSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("ignoreMustRevalidate", &HybridMhtSpec::getIgnoreMustRevalidate);
+      prototype.registerHybridSetter("ignoreMustRevalidate", &HybridMhtSpec::setIgnoreMustRevalidate);
+      prototype.registerHybridGetter("ignoreNoCache", &HybridMhtSpec::getIgnoreNoCache);
+      prototype.registerHybridSetter("ignoreNoCache", &HybridMhtSpec::setIgnoreNoCache);
+      prototype.registerHybridGetter("noScripts", &HybridMhtSpec::getNoScripts);
+      prototype.registerHybridSetter("noScripts", &HybridMhtSpec::setNoScripts);
+      prototype.registerHybridGetter("ntlmAuth", &HybridMhtSpec::getNtlmAuth);
+      prototype.registerHybridSetter("ntlmAuth", &HybridMhtSpec::setNtlmAuth);
+      prototype.registerHybridGetter("numCacheLevels", &HybridMhtSpec::getNumCacheLevels);
+      prototype.registerHybridSetter("numCacheLevels", &HybridMhtSpec::setNumCacheLevels);
+      prototype.registerHybridGetter("numCacheRoots", &HybridMhtSpec::getNumCacheRoots);
+      prototype.registerHybridGetter("preferIpv6", &HybridMhtSpec::getPreferIpv6);
+      prototype.registerHybridSetter("preferIpv6", &HybridMhtSpec::setPreferIpv6);
+      prototype.registerHybridGetter("preferMHTScripts", &HybridMhtSpec::getPreferMHTScripts);
+      prototype.registerHybridSetter("preferMHTScripts", &HybridMhtSpec::setPreferMHTScripts);
+      prototype.registerHybridGetter("proxy", &HybridMhtSpec::getProxy);
+      prototype.registerHybridSetter("proxy", &HybridMhtSpec::setProxy);
+      prototype.registerHybridGetter("proxyLogin", &HybridMhtSpec::getProxyLogin);
+      prototype.registerHybridSetter("proxyLogin", &HybridMhtSpec::setProxyLogin);
+      prototype.registerHybridGetter("proxyPassword", &HybridMhtSpec::getProxyPassword);
+      prototype.registerHybridSetter("proxyPassword", &HybridMhtSpec::setProxyPassword);
+      prototype.registerHybridGetter("readTimeout", &HybridMhtSpec::getReadTimeout);
+      prototype.registerHybridSetter("readTimeout", &HybridMhtSpec::setReadTimeout);
+      prototype.registerHybridGetter("requireSslCertVerify", &HybridMhtSpec::getRequireSslCertVerify);
+      prototype.registerHybridSetter("requireSslCertVerify", &HybridMhtSpec::setRequireSslCertVerify);
+      prototype.registerHybridGetter("socksHostname", &HybridMhtSpec::getSocksHostname);
+      prototype.registerHybridSetter("socksHostname", &HybridMhtSpec::setSocksHostname);
+      prototype.registerHybridGetter("socksPassword", &HybridMhtSpec::getSocksPassword);
+      prototype.registerHybridSetter("socksPassword", &HybridMhtSpec::setSocksPassword);
+      prototype.registerHybridGetter("socksPort", &HybridMhtSpec::getSocksPort);
+      prototype.registerHybridSetter("socksPort", &HybridMhtSpec::setSocksPort);
+      prototype.registerHybridGetter("socksUsername", &HybridMhtSpec::getSocksUsername);
+      prototype.registerHybridSetter("socksUsername", &HybridMhtSpec::setSocksUsername);
+      prototype.registerHybridGetter("socksVersion", &HybridMhtSpec::getSocksVersion);
+      prototype.registerHybridSetter("socksVersion", &HybridMhtSpec::setSocksVersion);
+      prototype.registerHybridGetter("unpackDirect", &HybridMhtSpec::getUnpackDirect);
+      prototype.registerHybridSetter("unpackDirect", &HybridMhtSpec::setUnpackDirect);
+      prototype.registerHybridGetter("unpackUseRelPaths", &HybridMhtSpec::getUnpackUseRelPaths);
+      prototype.registerHybridSetter("unpackUseRelPaths", &HybridMhtSpec::setUnpackUseRelPaths);
+      prototype.registerHybridGetter("updateCache", &HybridMhtSpec::getUpdateCache);
+      prototype.registerHybridSetter("updateCache", &HybridMhtSpec::setUpdateCache);
+      prototype.registerHybridGetter("useCids", &HybridMhtSpec::getUseCids);
+      prototype.registerHybridSetter("useCids", &HybridMhtSpec::setUseCids);
+      prototype.registerHybridGetter("useFilename", &HybridMhtSpec::getUseFilename);
+      prototype.registerHybridSetter("useFilename", &HybridMhtSpec::setUseFilename);
+      prototype.registerHybridGetter("useIEProxy", &HybridMhtSpec::getUseIEProxy);
+      prototype.registerHybridSetter("useIEProxy", &HybridMhtSpec::setUseIEProxy);
+      prototype.registerHybridGetter("useInline", &HybridMhtSpec::getUseInline);
+      prototype.registerHybridSetter("useInline", &HybridMhtSpec::setUseInline);
+      prototype.registerHybridGetter("webSiteLogin", &HybridMhtSpec::getWebSiteLogin);
+      prototype.registerHybridSetter("webSiteLogin", &HybridMhtSpec::setWebSiteLogin);
+      prototype.registerHybridGetter("webSiteLoginDomain", &HybridMhtSpec::getWebSiteLoginDomain);
+      prototype.registerHybridSetter("webSiteLoginDomain", &HybridMhtSpec::setWebSiteLoginDomain);
+      prototype.registerHybridGetter("webSitePassword", &HybridMhtSpec::getWebSitePassword);
+      prototype.registerHybridSetter("webSitePassword", &HybridMhtSpec::setWebSitePassword);
+      prototype.registerHybridGetter("abortCurrent", &HybridMhtSpec::getAbortCurrent);
+      prototype.registerHybridSetter("abortCurrent", &HybridMhtSpec::setAbortCurrent);
+      prototype.registerHybridGetter("onPercentDone", &HybridMhtSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridMhtSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridMhtSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridMhtSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("addCacheRoot", &HybridMhtSpec::addCacheRoot);
+      prototype.registerHybridMethod("addCustomHeader", &HybridMhtSpec::addCustomHeader);
+      prototype.registerHybridMethod("addExternalStyleSheet", &HybridMhtSpec::addExternalStyleSheet);
+      prototype.registerHybridMethod("clearCustomHeaders", &HybridMhtSpec::clearCustomHeaders);
+      prototype.registerHybridMethod("excludeImagesMatching", &HybridMhtSpec::excludeImagesMatching);
+      prototype.registerHybridMethod("getAndSaveEML", &HybridMhtSpec::getAndSaveEML);
+      prototype.registerHybridMethod("getAndSaveEMLAsync", &HybridMhtSpec::getAndSaveEMLAsync);
+      prototype.registerHybridMethod("getAndSaveMHT", &HybridMhtSpec::getAndSaveMHT);
+      prototype.registerHybridMethod("getAndSaveMHTAsync", &HybridMhtSpec::getAndSaveMHTAsync);
+      prototype.registerHybridMethod("getAndZipEML", &HybridMhtSpec::getAndZipEML);
+      prototype.registerHybridMethod("getAndZipEMLAsync", &HybridMhtSpec::getAndZipEMLAsync);
+      prototype.registerHybridMethod("getAndZipMHT", &HybridMhtSpec::getAndZipMHT);
+      prototype.registerHybridMethod("getAndZipMHTAsync", &HybridMhtSpec::getAndZipMHTAsync);
+      prototype.registerHybridMethod("getCacheRoot", &HybridMhtSpec::getCacheRoot);
+      prototype.registerHybridMethod("getEML", &HybridMhtSpec::getEML);
+      prototype.registerHybridMethod("getEMLAsync", &HybridMhtSpec::getEMLAsync);
+      prototype.registerHybridMethod("getMHT", &HybridMhtSpec::getMHT);
+      prototype.registerHybridMethod("getMHTAsync", &HybridMhtSpec::getMHTAsync);
+      prototype.registerHybridMethod("htmlToEML", &HybridMhtSpec::htmlToEML);
+      prototype.registerHybridMethod("htmlToEMLAsync", &HybridMhtSpec::htmlToEMLAsync);
+      prototype.registerHybridMethod("htmlToEMLFile", &HybridMhtSpec::htmlToEMLFile);
+      prototype.registerHybridMethod("htmlToEMLFileAsync", &HybridMhtSpec::htmlToEMLFileAsync);
+      prototype.registerHybridMethod("htmlToMHT", &HybridMhtSpec::htmlToMHT);
+      prototype.registerHybridMethod("htmlToMHTAsync", &HybridMhtSpec::htmlToMHTAsync);
+      prototype.registerHybridMethod("htmlToMHTFile", &HybridMhtSpec::htmlToMHTFile);
+      prototype.registerHybridMethod("htmlToMHTFileAsync", &HybridMhtSpec::htmlToMHTFileAsync);
+      prototype.registerHybridMethod("removeCustomHeader", &HybridMhtSpec::removeCustomHeader);
+      prototype.registerHybridMethod("restoreDefaults", &HybridMhtSpec::restoreDefaults);
+      prototype.registerHybridMethod("unpackMHT", &HybridMhtSpec::unpackMHT);
+      prototype.registerHybridMethod("unpackMHTString", &HybridMhtSpec::unpackMHTString);
+      prototype.registerHybridMethod("abort", &HybridMhtSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,181 @@
+///
+/// HybridMhtSpec.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 `Mht`
+   * Inherit this class to create instances of `HybridMhtSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridMht: public HybridMhtSpec {
+   * public:
+   *   HybridMht(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridMhtSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridMhtSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridMhtSpec() 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 getBaseUrl() = 0;
+      virtual void setBaseUrl(const std::string& baseUrl) = 0;
+      virtual double getConnectTimeout() = 0;
+      virtual void setConnectTimeout(double connectTimeout) = 0;
+      virtual std::string getDebugHtmlAfter() = 0;
+      virtual void setDebugHtmlAfter(const std::string& debugHtmlAfter) = 0;
+      virtual std::string getDebugHtmlBefore() = 0;
+      virtual void setDebugHtmlBefore(const std::string& debugHtmlBefore) = 0;
+      virtual bool getEmbedImages() = 0;
+      virtual void setEmbedImages(bool embedImages) = 0;
+      virtual bool getEmbedLocalOnly() = 0;
+      virtual void setEmbedLocalOnly(bool embedLocalOnly) = 0;
+      virtual bool getFetchFromCache() = 0;
+      virtual void setFetchFromCache(bool fetchFromCache) = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual bool getIgnoreMustRevalidate() = 0;
+      virtual void setIgnoreMustRevalidate(bool ignoreMustRevalidate) = 0;
+      virtual bool getIgnoreNoCache() = 0;
+      virtual void setIgnoreNoCache(bool ignoreNoCache) = 0;
+      virtual bool getNoScripts() = 0;
+      virtual void setNoScripts(bool noScripts) = 0;
+      virtual bool getNtlmAuth() = 0;
+      virtual void setNtlmAuth(bool ntlmAuth) = 0;
+      virtual double getNumCacheLevels() = 0;
+      virtual void setNumCacheLevels(double numCacheLevels) = 0;
+      virtual double getNumCacheRoots() = 0;
+      virtual bool getPreferIpv6() = 0;
+      virtual void setPreferIpv6(bool preferIpv6) = 0;
+      virtual bool getPreferMHTScripts() = 0;
+      virtual void setPreferMHTScripts(bool preferMHTScripts) = 0;
+      virtual std::string getProxy() = 0;
+      virtual void setProxy(const std::string& proxy) = 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 getReadTimeout() = 0;
+      virtual void setReadTimeout(double readTimeout) = 0;
+      virtual bool getRequireSslCertVerify() = 0;
+      virtual void setRequireSslCertVerify(bool requireSslCertVerify) = 0;
+      virtual std::string getSocksHostname() = 0;
+      virtual void setSocksHostname(const std::string& socksHostname) = 0;
+      virtual std::string getSocksPassword() = 0;
+      virtual void setSocksPassword(const std::string& socksPassword) = 0;
+      virtual double getSocksPort() = 0;
+      virtual void setSocksPort(double socksPort) = 0;
+      virtual std::string getSocksUsername() = 0;
+      virtual void setSocksUsername(const std::string& socksUsername) = 0;
+      virtual double getSocksVersion() = 0;
+      virtual void setSocksVersion(double socksVersion) = 0;
+      virtual bool getUnpackDirect() = 0;
+      virtual void setUnpackDirect(bool unpackDirect) = 0;
+      virtual bool getUnpackUseRelPaths() = 0;
+      virtual void setUnpackUseRelPaths(bool unpackUseRelPaths) = 0;
+      virtual bool getUpdateCache() = 0;
+      virtual void setUpdateCache(bool updateCache) = 0;
+      virtual bool getUseCids() = 0;
+      virtual void setUseCids(bool useCids) = 0;
+      virtual bool getUseFilename() = 0;
+      virtual void setUseFilename(bool useFilename) = 0;
+      virtual bool getUseIEProxy() = 0;
+      virtual void setUseIEProxy(bool useIEProxy) = 0;
+      virtual bool getUseInline() = 0;
+      virtual void setUseInline(bool useInline) = 0;
+      virtual std::string getWebSiteLogin() = 0;
+      virtual void setWebSiteLogin(const std::string& webSiteLogin) = 0;
+      virtual std::string getWebSiteLoginDomain() = 0;
+      virtual void setWebSiteLoginDomain(const std::string& webSiteLoginDomain) = 0;
+      virtual std::string getWebSitePassword() = 0;
+      virtual void setWebSitePassword(const std::string& webSitePassword) = 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 addCacheRoot(const std::string& dir) = 0;
+      virtual void addCustomHeader(const std::string& name, const std::string& value) = 0;
+      virtual void addExternalStyleSheet(const std::string& url) = 0;
+      virtual void clearCustomHeaders() = 0;
+      virtual void excludeImagesMatching(const std::string& pattern) = 0;
+      virtual void getAndSaveEML(const std::string& urlOrHtmlFilepath, const std::string& emlPath) = 0;
+      virtual std::shared_ptr<Promise<void>> getAndSaveEMLAsync(const std::string& urlOrHtmlFilepath, const std::string& emlPath) = 0;
+      virtual void getAndSaveMHT(const std::string& urlOrHtmlFilepath, const std::string& mhtPath) = 0;
+      virtual std::shared_ptr<Promise<void>> getAndSaveMHTAsync(const std::string& urlOrHtmlFilepath, const std::string& mhtPath) = 0;
+      virtual void getAndZipEML(const std::string& urlOrHtmlFilepath, const std::string& zipEntryFilename, const std::string& zipFilename) = 0;
+      virtual std::shared_ptr<Promise<void>> getAndZipEMLAsync(const std::string& urlOrHtmlFilepath, const std::string& zipEntryFilename, const std::string& zipFilename) = 0;
+      virtual void getAndZipMHT(const std::string& urlOrHtmlFilepath, const std::string& zipEntryFilename, const std::string& zipFilename) = 0;
+      virtual std::shared_ptr<Promise<void>> getAndZipMHTAsync(const std::string& urlOrHtmlFilepath, const std::string& zipEntryFilename, const std::string& zipFilename) = 0;
+      virtual std::string getCacheRoot(double index) = 0;
+      virtual std::string getEML(const std::string& urlOrHtmlFilepath) = 0;
+      virtual std::shared_ptr<Promise<std::string>> getEMLAsync(const std::string& urlOrHtmlFilepath) = 0;
+      virtual std::string getMHT(const std::string& urlOrHtmlFilepath) = 0;
+      virtual std::shared_ptr<Promise<std::string>> getMHTAsync(const std::string& urlOrHtmlFilepath) = 0;
+      virtual std::string htmlToEML(const std::string& htmlText) = 0;
+      virtual std::shared_ptr<Promise<std::string>> htmlToEMLAsync(const std::string& htmlText) = 0;
+      virtual void htmlToEMLFile(const std::string& html, const std::string& emlFilename) = 0;
+      virtual std::shared_ptr<Promise<void>> htmlToEMLFileAsync(const std::string& html, const std::string& emlFilename) = 0;
+      virtual std::string htmlToMHT(const std::string& htmlText) = 0;
+      virtual std::shared_ptr<Promise<std::string>> htmlToMHTAsync(const std::string& htmlText) = 0;
+      virtual void htmlToMHTFile(const std::string& html, const std::string& mhtFilename) = 0;
+      virtual std::shared_ptr<Promise<void>> htmlToMHTFileAsync(const std::string& html, const std::string& mhtFilename) = 0;
+      virtual void removeCustomHeader(const std::string& name) = 0;
+      virtual void restoreDefaults() = 0;
+      virtual void unpackMHT(const std::string& mhtFilename, const std::string& unpackDir, const std::string& htmlFilename, const std::string& partsSubDir) = 0;
+      virtual void unpackMHTString(const std::string& mhtString, const std::string& unpackDir, const std::string& htmlFilename, const std::string& partsSubDir) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Mht";
+  };
+
+} // namespace margelo::nitro::chilkat