@chilkat/react-native 11.6.1

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

@@ -0,0 +1,110 @@
+///
+/// HybridSpiderSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridSpiderSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridSpiderSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridSpiderSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridSpiderSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridSpiderSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridSpiderSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridSpiderSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridSpiderSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridSpiderSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridSpiderSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridSpiderSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridSpiderSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("avoidHttps", &HybridSpiderSpec::getAvoidHttps);
+      prototype.registerHybridSetter("avoidHttps", &HybridSpiderSpec::setAvoidHttps);
+      prototype.registerHybridGetter("cacheDir", &HybridSpiderSpec::getCacheDir);
+      prototype.registerHybridSetter("cacheDir", &HybridSpiderSpec::setCacheDir);
+      prototype.registerHybridGetter("chopAtQuery", &HybridSpiderSpec::getChopAtQuery);
+      prototype.registerHybridSetter("chopAtQuery", &HybridSpiderSpec::setChopAtQuery);
+      prototype.registerHybridGetter("connectTimeout", &HybridSpiderSpec::getConnectTimeout);
+      prototype.registerHybridSetter("connectTimeout", &HybridSpiderSpec::setConnectTimeout);
+      prototype.registerHybridGetter("domain", &HybridSpiderSpec::getDomain);
+      prototype.registerHybridGetter("fetchFromCache", &HybridSpiderSpec::getFetchFromCache);
+      prototype.registerHybridSetter("fetchFromCache", &HybridSpiderSpec::setFetchFromCache);
+      prototype.registerHybridGetter("heartbeatMs", &HybridSpiderSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridSpiderSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("lastFromCache", &HybridSpiderSpec::getLastFromCache);
+      prototype.registerHybridGetter("lastHtml", &HybridSpiderSpec::getLastHtml);
+      prototype.registerHybridGetter("lastHtmlDescription", &HybridSpiderSpec::getLastHtmlDescription);
+      prototype.registerHybridGetter("lastHtmlKeywords", &HybridSpiderSpec::getLastHtmlKeywords);
+      prototype.registerHybridGetter("lastHtmlTitle", &HybridSpiderSpec::getLastHtmlTitle);
+      prototype.registerHybridGetter("lastModDateStr", &HybridSpiderSpec::getLastModDateStr);
+      prototype.registerHybridGetter("lastUrl", &HybridSpiderSpec::getLastUrl);
+      prototype.registerHybridGetter("maxResponseSize", &HybridSpiderSpec::getMaxResponseSize);
+      prototype.registerHybridSetter("maxResponseSize", &HybridSpiderSpec::setMaxResponseSize);
+      prototype.registerHybridGetter("maxUrlLen", &HybridSpiderSpec::getMaxUrlLen);
+      prototype.registerHybridSetter("maxUrlLen", &HybridSpiderSpec::setMaxUrlLen);
+      prototype.registerHybridGetter("numAvoidPatterns", &HybridSpiderSpec::getNumAvoidPatterns);
+      prototype.registerHybridGetter("numFailed", &HybridSpiderSpec::getNumFailed);
+      prototype.registerHybridGetter("numOutboundLinks", &HybridSpiderSpec::getNumOutboundLinks);
+      prototype.registerHybridGetter("numSpidered", &HybridSpiderSpec::getNumSpidered);
+      prototype.registerHybridGetter("numUnspidered", &HybridSpiderSpec::getNumUnspidered);
+      prototype.registerHybridGetter("preferIpv6", &HybridSpiderSpec::getPreferIpv6);
+      prototype.registerHybridSetter("preferIpv6", &HybridSpiderSpec::setPreferIpv6);
+      prototype.registerHybridGetter("proxyDomain", &HybridSpiderSpec::getProxyDomain);
+      prototype.registerHybridSetter("proxyDomain", &HybridSpiderSpec::setProxyDomain);
+      prototype.registerHybridGetter("proxyLogin", &HybridSpiderSpec::getProxyLogin);
+      prototype.registerHybridSetter("proxyLogin", &HybridSpiderSpec::setProxyLogin);
+      prototype.registerHybridGetter("proxyPassword", &HybridSpiderSpec::getProxyPassword);
+      prototype.registerHybridSetter("proxyPassword", &HybridSpiderSpec::setProxyPassword);
+      prototype.registerHybridGetter("proxyPort", &HybridSpiderSpec::getProxyPort);
+      prototype.registerHybridSetter("proxyPort", &HybridSpiderSpec::setProxyPort);
+      prototype.registerHybridGetter("readTimeout", &HybridSpiderSpec::getReadTimeout);
+      prototype.registerHybridSetter("readTimeout", &HybridSpiderSpec::setReadTimeout);
+      prototype.registerHybridGetter("updateCache", &HybridSpiderSpec::getUpdateCache);
+      prototype.registerHybridSetter("updateCache", &HybridSpiderSpec::setUpdateCache);
+      prototype.registerHybridGetter("userAgent", &HybridSpiderSpec::getUserAgent);
+      prototype.registerHybridSetter("userAgent", &HybridSpiderSpec::setUserAgent);
+      prototype.registerHybridGetter("windDownCount", &HybridSpiderSpec::getWindDownCount);
+      prototype.registerHybridSetter("windDownCount", &HybridSpiderSpec::setWindDownCount);
+      prototype.registerHybridGetter("abortCurrent", &HybridSpiderSpec::getAbortCurrent);
+      prototype.registerHybridSetter("abortCurrent", &HybridSpiderSpec::setAbortCurrent);
+      prototype.registerHybridGetter("wasRedirected", &HybridSpiderSpec::getWasRedirected);
+      prototype.registerHybridGetter("finalRedirectUrl", &HybridSpiderSpec::getFinalRedirectUrl);
+      prototype.registerHybridGetter("onPercentDone", &HybridSpiderSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridSpiderSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridSpiderSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridSpiderSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("addAvoidOutboundLinkPattern", &HybridSpiderSpec::addAvoidOutboundLinkPattern);
+      prototype.registerHybridMethod("addAvoidPattern", &HybridSpiderSpec::addAvoidPattern);
+      prototype.registerHybridMethod("addMustMatchPattern", &HybridSpiderSpec::addMustMatchPattern);
+      prototype.registerHybridMethod("addUnspidered", &HybridSpiderSpec::addUnspidered);
+      prototype.registerHybridMethod("canonicalizeUrl", &HybridSpiderSpec::canonicalizeUrl);
+      prototype.registerHybridMethod("clearFailedUrls", &HybridSpiderSpec::clearFailedUrls);
+      prototype.registerHybridMethod("clearOutboundLinks", &HybridSpiderSpec::clearOutboundLinks);
+      prototype.registerHybridMethod("clearSpideredUrls", &HybridSpiderSpec::clearSpideredUrls);
+      prototype.registerHybridMethod("crawlNext", &HybridSpiderSpec::crawlNext);
+      prototype.registerHybridMethod("crawlNextAsync", &HybridSpiderSpec::crawlNextAsync);
+      prototype.registerHybridMethod("fetchRobotsText", &HybridSpiderSpec::fetchRobotsText);
+      prototype.registerHybridMethod("fetchRobotsTextAsync", &HybridSpiderSpec::fetchRobotsTextAsync);
+      prototype.registerHybridMethod("getAvoidPattern", &HybridSpiderSpec::getAvoidPattern);
+      prototype.registerHybridMethod("getBaseDomain", &HybridSpiderSpec::getBaseDomain);
+      prototype.registerHybridMethod("getFailedUrl", &HybridSpiderSpec::getFailedUrl);
+      prototype.registerHybridMethod("getOutboundLink", &HybridSpiderSpec::getOutboundLink);
+      prototype.registerHybridMethod("getSpideredUrl", &HybridSpiderSpec::getSpideredUrl);
+      prototype.registerHybridMethod("getUnspideredUrl", &HybridSpiderSpec::getUnspideredUrl);
+      prototype.registerHybridMethod("getUrlDomain", &HybridSpiderSpec::getUrlDomain);
+      prototype.registerHybridMethod("initialize", &HybridSpiderSpec::initialize);
+      prototype.registerHybridMethod("recrawlLast", &HybridSpiderSpec::recrawlLast);
+      prototype.registerHybridMethod("recrawlLastAsync", &HybridSpiderSpec::recrawlLastAsync);
+      prototype.registerHybridMethod("skipUnspidered", &HybridSpiderSpec::skipUnspidered);
+      prototype.registerHybridMethod("sleepMs", &HybridSpiderSpec::sleepMs);
+      prototype.registerHybridMethod("abort", &HybridSpiderSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,153 @@
+///
+/// HybridSpiderSpec.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 `Spider`
+   * Inherit this class to create instances of `HybridSpiderSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridSpider: public HybridSpiderSpec {
+   * public:
+   *   HybridSpider(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridSpiderSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridSpiderSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridSpiderSpec() 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 bool getAvoidHttps() = 0;
+      virtual void setAvoidHttps(bool avoidHttps) = 0;
+      virtual std::string getCacheDir() = 0;
+      virtual void setCacheDir(const std::string& cacheDir) = 0;
+      virtual bool getChopAtQuery() = 0;
+      virtual void setChopAtQuery(bool chopAtQuery) = 0;
+      virtual double getConnectTimeout() = 0;
+      virtual void setConnectTimeout(double connectTimeout) = 0;
+      virtual std::string getDomain() = 0;
+      virtual bool getFetchFromCache() = 0;
+      virtual void setFetchFromCache(bool fetchFromCache) = 0;
+      virtual double getHeartbeatMs() = 0;
+      virtual void setHeartbeatMs(double heartbeatMs) = 0;
+      virtual bool getLastFromCache() = 0;
+      virtual std::string getLastHtml() = 0;
+      virtual std::string getLastHtmlDescription() = 0;
+      virtual std::string getLastHtmlKeywords() = 0;
+      virtual std::string getLastHtmlTitle() = 0;
+      virtual std::string getLastModDateStr() = 0;
+      virtual std::string getLastUrl() = 0;
+      virtual double getMaxResponseSize() = 0;
+      virtual void setMaxResponseSize(double maxResponseSize) = 0;
+      virtual double getMaxUrlLen() = 0;
+      virtual void setMaxUrlLen(double maxUrlLen) = 0;
+      virtual double getNumAvoidPatterns() = 0;
+      virtual double getNumFailed() = 0;
+      virtual double getNumOutboundLinks() = 0;
+      virtual double getNumSpidered() = 0;
+      virtual double getNumUnspidered() = 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 double getReadTimeout() = 0;
+      virtual void setReadTimeout(double readTimeout) = 0;
+      virtual bool getUpdateCache() = 0;
+      virtual void setUpdateCache(bool updateCache) = 0;
+      virtual std::string getUserAgent() = 0;
+      virtual void setUserAgent(const std::string& userAgent) = 0;
+      virtual double getWindDownCount() = 0;
+      virtual void setWindDownCount(double windDownCount) = 0;
+      virtual bool getAbortCurrent() = 0;
+      virtual void setAbortCurrent(bool abortCurrent) = 0;
+      virtual bool getWasRedirected() = 0;
+      virtual std::string getFinalRedirectUrl() = 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 addAvoidOutboundLinkPattern(const std::string& pattern) = 0;
+      virtual void addAvoidPattern(const std::string& pattern) = 0;
+      virtual void addMustMatchPattern(const std::string& pattern) = 0;
+      virtual void addUnspidered(const std::string& url) = 0;
+      virtual std::string canonicalizeUrl(const std::string& url) = 0;
+      virtual void clearFailedUrls() = 0;
+      virtual void clearOutboundLinks() = 0;
+      virtual void clearSpideredUrls() = 0;
+      virtual void crawlNext() = 0;
+      virtual std::shared_ptr<Promise<void>> crawlNextAsync() = 0;
+      virtual std::string fetchRobotsText() = 0;
+      virtual std::shared_ptr<Promise<std::string>> fetchRobotsTextAsync() = 0;
+      virtual std::string getAvoidPattern(double index) = 0;
+      virtual std::string getBaseDomain(const std::string& domain) = 0;
+      virtual std::string getFailedUrl(double index) = 0;
+      virtual std::string getOutboundLink(double index) = 0;
+      virtual std::string getSpideredUrl(double index) = 0;
+      virtual std::string getUnspideredUrl(double index) = 0;
+      virtual std::string getUrlDomain(const std::string& url) = 0;
+      virtual void initialize(const std::string& domain) = 0;
+      virtual void recrawlLast() = 0;
+      virtual std::shared_ptr<Promise<void>> recrawlLastAsync() = 0;
+      virtual void skipUnspidered(double index) = 0;
+      virtual void sleepMs(double numMilliseconds) = 0;
+      virtual void abort() = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Spider";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,59 @@
+///
+/// HybridSshKeySpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridSshKeySpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridSshKeySpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridSshKeySpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridSshKeySpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridSshKeySpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridSshKeySpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridSshKeySpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridSshKeySpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridSshKeySpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridSshKeySpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridSshKeySpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridSshKeySpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("comment", &HybridSshKeySpec::getComment);
+      prototype.registerHybridSetter("comment", &HybridSshKeySpec::setComment);
+      prototype.registerHybridGetter("isDsaKey", &HybridSshKeySpec::getIsDsaKey);
+      prototype.registerHybridGetter("isPrivateKey", &HybridSshKeySpec::getIsPrivateKey);
+      prototype.registerHybridGetter("isRsaKey", &HybridSshKeySpec::getIsRsaKey);
+      prototype.registerHybridGetter("password", &HybridSshKeySpec::getPassword);
+      prototype.registerHybridSetter("password", &HybridSshKeySpec::setPassword);
+      prototype.registerHybridGetter("keyType", &HybridSshKeySpec::getKeyType);
+      prototype.registerHybridGetter("uncommonOptions", &HybridSshKeySpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridSshKeySpec::setUncommonOptions);
+      prototype.registerHybridMethod("fromOpenSshPrivateKey", &HybridSshKeySpec::fromOpenSshPrivateKey);
+      prototype.registerHybridMethod("fromOpenSshPublicKey", &HybridSshKeySpec::fromOpenSshPublicKey);
+      prototype.registerHybridMethod("fromPuttyPrivateKey", &HybridSshKeySpec::fromPuttyPrivateKey);
+      prototype.registerHybridMethod("fromRfc4716PublicKey", &HybridSshKeySpec::fromRfc4716PublicKey);
+      prototype.registerHybridMethod("fromXml", &HybridSshKeySpec::fromXml);
+      prototype.registerHybridMethod("genFingerprint", &HybridSshKeySpec::genFingerprint);
+      prototype.registerHybridMethod("generateDsaKey", &HybridSshKeySpec::generateDsaKey);
+      prototype.registerHybridMethod("generateRsaKey", &HybridSshKeySpec::generateRsaKey);
+      prototype.registerHybridMethod("loadText", &HybridSshKeySpec::loadText);
+      prototype.registerHybridMethod("saveText", &HybridSshKeySpec::saveText);
+      prototype.registerHybridMethod("toOpenSshPrivateKey", &HybridSshKeySpec::toOpenSshPrivateKey);
+      prototype.registerHybridMethod("toOpenSshPublicKey", &HybridSshKeySpec::toOpenSshPublicKey);
+      prototype.registerHybridMethod("toPuttyPrivateKey", &HybridSshKeySpec::toPuttyPrivateKey);
+      prototype.registerHybridMethod("toRfc4716PublicKey", &HybridSshKeySpec::toRfc4716PublicKey);
+      prototype.registerHybridMethod("toXml", &HybridSshKeySpec::toXml);
+      prototype.registerHybridMethod("generateEd25519Key", &HybridSshKeySpec::generateEd25519Key);
+      prototype.registerHybridMethod("generateEcdsaKey", &HybridSshKeySpec::generateEcdsaKey);
+      prototype.registerHybridMethod("usePkcs11", &HybridSshKeySpec::usePkcs11);
+      prototype.registerHybridMethod("useSshCertificate", &HybridSshKeySpec::useSshCertificate);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,102 @@
+///
+/// HybridSshKeySpec.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 `HybridPkcs11Spec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPkcs11Spec; }
+
+#include <string>
+#include <memory>
+#include "HybridPkcs11Spec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `SshKey`
+   * Inherit this class to create instances of `HybridSshKeySpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridSshKey: public HybridSshKeySpec {
+   * public:
+   *   HybridSshKey(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridSshKeySpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridSshKeySpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridSshKeySpec() 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 getComment() = 0;
+      virtual void setComment(const std::string& comment) = 0;
+      virtual bool getIsDsaKey() = 0;
+      virtual bool getIsPrivateKey() = 0;
+      virtual bool getIsRsaKey() = 0;
+      virtual std::string getPassword() = 0;
+      virtual void setPassword(const std::string& password) = 0;
+      virtual std::string getKeyType() = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+
+    public:
+      // Methods
+      virtual void fromOpenSshPrivateKey(const std::string& keyStr) = 0;
+      virtual void fromOpenSshPublicKey(const std::string& keyStr) = 0;
+      virtual void fromPuttyPrivateKey(const std::string& keyStr) = 0;
+      virtual void fromRfc4716PublicKey(const std::string& keyStr) = 0;
+      virtual void fromXml(const std::string& xmlKey) = 0;
+      virtual std::string genFingerprint() = 0;
+      virtual void generateDsaKey(double numBits) = 0;
+      virtual void generateRsaKey(double numBits, double exponent) = 0;
+      virtual std::string loadText(const std::string& filename) = 0;
+      virtual void saveText(const std::string& strToSave, const std::string& filename) = 0;
+      virtual std::string toOpenSshPrivateKey(bool bEncrypt) = 0;
+      virtual std::string toOpenSshPublicKey() = 0;
+      virtual std::string toPuttyPrivateKey(bool bEncrypt) = 0;
+      virtual std::string toRfc4716PublicKey() = 0;
+      virtual std::string toXml() = 0;
+      virtual void generateEd25519Key() = 0;
+      virtual void generateEcdsaKey(const std::string& curveName) = 0;
+      virtual void usePkcs11(const std::shared_ptr<HybridPkcs11Spec>& session, double privKeyHandle, double pubKeyHandle, const std::string& keyType) = 0;
+      virtual void useSshCertificate(const std::string& sshCert) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "SshKey";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,215 @@
+///
+/// HybridSshSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridSshSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridSshSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridSshSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridSshSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridSshSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridSshSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridSshSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridSshSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridSshSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridSshSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridSshSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridSshSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("authFailReason", &HybridSshSpec::getAuthFailReason);
+      prototype.registerHybridGetter("caretControl", &HybridSshSpec::getCaretControl);
+      prototype.registerHybridSetter("caretControl", &HybridSshSpec::setCaretControl);
+      prototype.registerHybridGetter("channelOpenFailCode", &HybridSshSpec::getChannelOpenFailCode);
+      prototype.registerHybridGetter("channelOpenFailReason", &HybridSshSpec::getChannelOpenFailReason);
+      prototype.registerHybridGetter("clientIdentifier", &HybridSshSpec::getClientIdentifier);
+      prototype.registerHybridSetter("clientIdentifier", &HybridSshSpec::setClientIdentifier);
+      prototype.registerHybridGetter("clientIpAddress", &HybridSshSpec::getClientIpAddress);
+      prototype.registerHybridSetter("clientIpAddress", &HybridSshSpec::setClientIpAddress);
+      prototype.registerHybridGetter("connectTimeoutMs", &HybridSshSpec::getConnectTimeoutMs);
+      prototype.registerHybridSetter("connectTimeoutMs", &HybridSshSpec::setConnectTimeoutMs);
+      prototype.registerHybridGetter("disconnectCode", &HybridSshSpec::getDisconnectCode);
+      prototype.registerHybridGetter("disconnectReason", &HybridSshSpec::getDisconnectReason);
+      prototype.registerHybridGetter("forceCipher", &HybridSshSpec::getForceCipher);
+      prototype.registerHybridSetter("forceCipher", &HybridSshSpec::setForceCipher);
+      prototype.registerHybridGetter("heartbeatMs", &HybridSshSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridSshSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("hostKeyAlg", &HybridSshSpec::getHostKeyAlg);
+      prototype.registerHybridSetter("hostKeyAlg", &HybridSshSpec::setHostKeyAlg);
+      prototype.registerHybridGetter("hostKeyFingerprint", &HybridSshSpec::getHostKeyFingerprint);
+      prototype.registerHybridGetter("httpProxyAuthMethod", &HybridSshSpec::getHttpProxyAuthMethod);
+      prototype.registerHybridSetter("httpProxyAuthMethod", &HybridSshSpec::setHttpProxyAuthMethod);
+      prototype.registerHybridGetter("httpProxyDomain", &HybridSshSpec::getHttpProxyDomain);
+      prototype.registerHybridSetter("httpProxyDomain", &HybridSshSpec::setHttpProxyDomain);
+      prototype.registerHybridGetter("httpProxyHostname", &HybridSshSpec::getHttpProxyHostname);
+      prototype.registerHybridSetter("httpProxyHostname", &HybridSshSpec::setHttpProxyHostname);
+      prototype.registerHybridGetter("httpProxyPassword", &HybridSshSpec::getHttpProxyPassword);
+      prototype.registerHybridSetter("httpProxyPassword", &HybridSshSpec::setHttpProxyPassword);
+      prototype.registerHybridGetter("httpProxyPort", &HybridSshSpec::getHttpProxyPort);
+      prototype.registerHybridSetter("httpProxyPort", &HybridSshSpec::setHttpProxyPort);
+      prototype.registerHybridGetter("httpProxyUsername", &HybridSshSpec::getHttpProxyUsername);
+      prototype.registerHybridSetter("httpProxyUsername", &HybridSshSpec::setHttpProxyUsername);
+      prototype.registerHybridGetter("idleTimeoutMs", &HybridSshSpec::getIdleTimeoutMs);
+      prototype.registerHybridSetter("idleTimeoutMs", &HybridSshSpec::setIdleTimeoutMs);
+      prototype.registerHybridGetter("isConnected", &HybridSshSpec::getIsConnected);
+      prototype.registerHybridGetter("keepSessionLog", &HybridSshSpec::getKeepSessionLog);
+      prototype.registerHybridSetter("keepSessionLog", &HybridSshSpec::setKeepSessionLog);
+      prototype.registerHybridGetter("maxPacketSize", &HybridSshSpec::getMaxPacketSize);
+      prototype.registerHybridSetter("maxPacketSize", &HybridSshSpec::setMaxPacketSize);
+      prototype.registerHybridGetter("numOpenChannels", &HybridSshSpec::getNumOpenChannels);
+      prototype.registerHybridGetter("passwordChangeRequested", &HybridSshSpec::getPasswordChangeRequested);
+      prototype.registerHybridGetter("preferIpv6", &HybridSshSpec::getPreferIpv6);
+      prototype.registerHybridSetter("preferIpv6", &HybridSshSpec::setPreferIpv6);
+      prototype.registerHybridGetter("readTimeoutMs", &HybridSshSpec::getReadTimeoutMs);
+      prototype.registerHybridSetter("readTimeoutMs", &HybridSshSpec::setReadTimeoutMs);
+      prototype.registerHybridGetter("reqExecCharset", &HybridSshSpec::getReqExecCharset);
+      prototype.registerHybridSetter("reqExecCharset", &HybridSshSpec::setReqExecCharset);
+      prototype.registerHybridGetter("sessionLog", &HybridSshSpec::getSessionLog);
+      prototype.registerHybridGetter("soRcvBuf", &HybridSshSpec::getSoRcvBuf);
+      prototype.registerHybridSetter("soRcvBuf", &HybridSshSpec::setSoRcvBuf);
+      prototype.registerHybridGetter("soSndBuf", &HybridSshSpec::getSoSndBuf);
+      prototype.registerHybridSetter("soSndBuf", &HybridSshSpec::setSoSndBuf);
+      prototype.registerHybridGetter("socksHostname", &HybridSshSpec::getSocksHostname);
+      prototype.registerHybridSetter("socksHostname", &HybridSshSpec::setSocksHostname);
+      prototype.registerHybridGetter("socksPassword", &HybridSshSpec::getSocksPassword);
+      prototype.registerHybridSetter("socksPassword", &HybridSshSpec::setSocksPassword);
+      prototype.registerHybridGetter("socksPort", &HybridSshSpec::getSocksPort);
+      prototype.registerHybridSetter("socksPort", &HybridSshSpec::setSocksPort);
+      prototype.registerHybridGetter("socksUsername", &HybridSshSpec::getSocksUsername);
+      prototype.registerHybridSetter("socksUsername", &HybridSshSpec::setSocksUsername);
+      prototype.registerHybridGetter("socksVersion", &HybridSshSpec::getSocksVersion);
+      prototype.registerHybridSetter("socksVersion", &HybridSshSpec::setSocksVersion);
+      prototype.registerHybridGetter("stderrToStdout", &HybridSshSpec::getStderrToStdout);
+      prototype.registerHybridSetter("stderrToStdout", &HybridSshSpec::setStderrToStdout);
+      prototype.registerHybridGetter("tcpNoDelay", &HybridSshSpec::getTcpNoDelay);
+      prototype.registerHybridSetter("tcpNoDelay", &HybridSshSpec::setTcpNoDelay);
+      prototype.registerHybridGetter("userAuthBanner", &HybridSshSpec::getUserAuthBanner);
+      prototype.registerHybridSetter("userAuthBanner", &HybridSshSpec::setUserAuthBanner);
+      prototype.registerHybridGetter("enableCompression", &HybridSshSpec::getEnableCompression);
+      prototype.registerHybridSetter("enableCompression", &HybridSshSpec::setEnableCompression);
+      prototype.registerHybridGetter("abortCurrent", &HybridSshSpec::getAbortCurrent);
+      prototype.registerHybridSetter("abortCurrent", &HybridSshSpec::setAbortCurrent);
+      prototype.registerHybridGetter("stripColorCodes", &HybridSshSpec::getStripColorCodes);
+      prototype.registerHybridSetter("stripColorCodes", &HybridSshSpec::setStripColorCodes);
+      prototype.registerHybridGetter("serverIdentifier", &HybridSshSpec::getServerIdentifier);
+      prototype.registerHybridGetter("uncommonOptions", &HybridSshSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridSshSpec::setUncommonOptions);
+      prototype.registerHybridGetter("clientPort", &HybridSshSpec::getClientPort);
+      prototype.registerHybridSetter("clientPort", &HybridSshSpec::setClientPort);
+      prototype.registerHybridGetter("enableSecrets", &HybridSshSpec::getEnableSecrets);
+      prototype.registerHybridSetter("enableSecrets", &HybridSshSpec::setEnableSecrets);
+      prototype.registerHybridGetter("onPercentDone", &HybridSshSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridSshSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridSshSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridSshSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("authenticatePk", &HybridSshSpec::authenticatePk);
+      prototype.registerHybridMethod("authenticatePkAsync", &HybridSshSpec::authenticatePkAsync);
+      prototype.registerHybridMethod("authenticatePw", &HybridSshSpec::authenticatePw);
+      prototype.registerHybridMethod("authenticatePwAsync", &HybridSshSpec::authenticatePwAsync);
+      prototype.registerHybridMethod("authenticatePwPk", &HybridSshSpec::authenticatePwPk);
+      prototype.registerHybridMethod("authenticatePwPkAsync", &HybridSshSpec::authenticatePwPkAsync);
+      prototype.registerHybridMethod("channelIsOpen", &HybridSshSpec::channelIsOpen);
+      prototype.registerHybridMethod("channelPoll", &HybridSshSpec::channelPoll);
+      prototype.registerHybridMethod("channelPollAsync", &HybridSshSpec::channelPollAsync);
+      prototype.registerHybridMethod("channelRead", &HybridSshSpec::channelRead);
+      prototype.registerHybridMethod("channelReadAsync", &HybridSshSpec::channelReadAsync);
+      prototype.registerHybridMethod("channelReadAndPoll", &HybridSshSpec::channelReadAndPoll);
+      prototype.registerHybridMethod("channelReadAndPollAsync", &HybridSshSpec::channelReadAndPollAsync);
+      prototype.registerHybridMethod("channelReadAndPoll2", &HybridSshSpec::channelReadAndPoll2);
+      prototype.registerHybridMethod("channelReadAndPoll2Async", &HybridSshSpec::channelReadAndPoll2Async);
+      prototype.registerHybridMethod("channelReceiveToClose", &HybridSshSpec::channelReceiveToClose);
+      prototype.registerHybridMethod("channelReceiveToCloseAsync", &HybridSshSpec::channelReceiveToCloseAsync);
+      prototype.registerHybridMethod("channelReceiveUntilMatch", &HybridSshSpec::channelReceiveUntilMatch);
+      prototype.registerHybridMethod("channelReceiveUntilMatchAsync", &HybridSshSpec::channelReceiveUntilMatchAsync);
+      prototype.registerHybridMethod("channelReceiveUntilMatchN", &HybridSshSpec::channelReceiveUntilMatchN);
+      prototype.registerHybridMethod("channelReceiveUntilMatchNAsync", &HybridSshSpec::channelReceiveUntilMatchNAsync);
+      prototype.registerHybridMethod("channelReceivedClose", &HybridSshSpec::channelReceivedClose);
+      prototype.registerHybridMethod("channelReceivedEof", &HybridSshSpec::channelReceivedEof);
+      prototype.registerHybridMethod("channelReceivedExitStatus", &HybridSshSpec::channelReceivedExitStatus);
+      prototype.registerHybridMethod("channelRelease", &HybridSshSpec::channelRelease);
+      prototype.registerHybridMethod("channelSendClose", &HybridSshSpec::channelSendClose);
+      prototype.registerHybridMethod("channelSendCloseAsync", &HybridSshSpec::channelSendCloseAsync);
+      prototype.registerHybridMethod("channelSendEof", &HybridSshSpec::channelSendEof);
+      prototype.registerHybridMethod("channelSendEofAsync", &HybridSshSpec::channelSendEofAsync);
+      prototype.registerHybridMethod("channelSendString", &HybridSshSpec::channelSendString);
+      prototype.registerHybridMethod("channelSendStringAsync", &HybridSshSpec::channelSendStringAsync);
+      prototype.registerHybridMethod("checkConnection", &HybridSshSpec::checkConnection);
+      prototype.registerHybridMethod("clearTtyModes", &HybridSshSpec::clearTtyModes);
+      prototype.registerHybridMethod("connect", &HybridSshSpec::connect);
+      prototype.registerHybridMethod("connectAsync", &HybridSshSpec::connectAsync);
+      prototype.registerHybridMethod("connectThroughSsh", &HybridSshSpec::connectThroughSsh);
+      prototype.registerHybridMethod("connectThroughSshAsync", &HybridSshSpec::connectThroughSshAsync);
+      prototype.registerHybridMethod("continueKeyboardAuth", &HybridSshSpec::continueKeyboardAuth);
+      prototype.registerHybridMethod("continueKeyboardAuthAsync", &HybridSshSpec::continueKeyboardAuthAsync);
+      prototype.registerHybridMethod("disconnect", &HybridSshSpec::disconnect);
+      prototype.registerHybridMethod("getChannelExitStatus", &HybridSshSpec::getChannelExitStatus);
+      prototype.registerHybridMethod("getChannelNumber", &HybridSshSpec::getChannelNumber);
+      prototype.registerHybridMethod("getChannelType", &HybridSshSpec::getChannelType);
+      prototype.registerHybridMethod("getReceivedNumBytes", &HybridSshSpec::getReceivedNumBytes);
+      prototype.registerHybridMethod("getReceivedStderrText", &HybridSshSpec::getReceivedStderrText);
+      prototype.registerHybridMethod("getReceivedText", &HybridSshSpec::getReceivedText);
+      prototype.registerHybridMethod("getReceivedTextS", &HybridSshSpec::getReceivedTextS);
+      prototype.registerHybridMethod("openCustomChannel", &HybridSshSpec::openCustomChannel);
+      prototype.registerHybridMethod("openCustomChannelAsync", &HybridSshSpec::openCustomChannelAsync);
+      prototype.registerHybridMethod("openDirectTcpIpChannel", &HybridSshSpec::openDirectTcpIpChannel);
+      prototype.registerHybridMethod("openDirectTcpIpChannelAsync", &HybridSshSpec::openDirectTcpIpChannelAsync);
+      prototype.registerHybridMethod("openSessionChannel", &HybridSshSpec::openSessionChannel);
+      prototype.registerHybridMethod("openSessionChannelAsync", &HybridSshSpec::openSessionChannelAsync);
+      prototype.registerHybridMethod("peekReceivedText", &HybridSshSpec::peekReceivedText);
+      prototype.registerHybridMethod("reKey", &HybridSshSpec::reKey);
+      prototype.registerHybridMethod("reKeyAsync", &HybridSshSpec::reKeyAsync);
+      prototype.registerHybridMethod("sendIgnore", &HybridSshSpec::sendIgnore);
+      prototype.registerHybridMethod("sendIgnoreAsync", &HybridSshSpec::sendIgnoreAsync);
+      prototype.registerHybridMethod("sendReqExec", &HybridSshSpec::sendReqExec);
+      prototype.registerHybridMethod("sendReqExecAsync", &HybridSshSpec::sendReqExecAsync);
+      prototype.registerHybridMethod("sendReqPty", &HybridSshSpec::sendReqPty);
+      prototype.registerHybridMethod("sendReqPtyAsync", &HybridSshSpec::sendReqPtyAsync);
+      prototype.registerHybridMethod("sendReqSetEnv", &HybridSshSpec::sendReqSetEnv);
+      prototype.registerHybridMethod("sendReqSetEnvAsync", &HybridSshSpec::sendReqSetEnvAsync);
+      prototype.registerHybridMethod("sendReqShell", &HybridSshSpec::sendReqShell);
+      prototype.registerHybridMethod("sendReqShellAsync", &HybridSshSpec::sendReqShellAsync);
+      prototype.registerHybridMethod("sendReqSignal", &HybridSshSpec::sendReqSignal);
+      prototype.registerHybridMethod("sendReqSignalAsync", &HybridSshSpec::sendReqSignalAsync);
+      prototype.registerHybridMethod("sendReqSubsystem", &HybridSshSpec::sendReqSubsystem);
+      prototype.registerHybridMethod("sendReqSubsystemAsync", &HybridSshSpec::sendReqSubsystemAsync);
+      prototype.registerHybridMethod("sendReqWindowChange", &HybridSshSpec::sendReqWindowChange);
+      prototype.registerHybridMethod("sendReqWindowChangeAsync", &HybridSshSpec::sendReqWindowChangeAsync);
+      prototype.registerHybridMethod("sendReqX11Forwarding", &HybridSshSpec::sendReqX11Forwarding);
+      prototype.registerHybridMethod("sendReqX11ForwardingAsync", &HybridSshSpec::sendReqX11ForwardingAsync);
+      prototype.registerHybridMethod("sendReqXonXoff", &HybridSshSpec::sendReqXonXoff);
+      prototype.registerHybridMethod("sendReqXonXoffAsync", &HybridSshSpec::sendReqXonXoffAsync);
+      prototype.registerHybridMethod("setTtyMode", &HybridSshSpec::setTtyMode);
+      prototype.registerHybridMethod("startKeyboardAuth", &HybridSshSpec::startKeyboardAuth);
+      prototype.registerHybridMethod("startKeyboardAuthAsync", &HybridSshSpec::startKeyboardAuthAsync);
+      prototype.registerHybridMethod("waitForChannelMessage", &HybridSshSpec::waitForChannelMessage);
+      prototype.registerHybridMethod("waitForChannelMessageAsync", &HybridSshSpec::waitForChannelMessageAsync);
+      prototype.registerHybridMethod("quickCommand", &HybridSshSpec::quickCommand);
+      prototype.registerHybridMethod("quickCommandAsync", &HybridSshSpec::quickCommandAsync);
+      prototype.registerHybridMethod("quickShell", &HybridSshSpec::quickShell);
+      prototype.registerHybridMethod("quickShellAsync", &HybridSshSpec::quickShellAsync);
+      prototype.registerHybridMethod("quickCmdSend", &HybridSshSpec::quickCmdSend);
+      prototype.registerHybridMethod("quickCmdSendAsync", &HybridSshSpec::quickCmdSendAsync);
+      prototype.registerHybridMethod("quickCmdCheck", &HybridSshSpec::quickCmdCheck);
+      prototype.registerHybridMethod("quickCmdCheckAsync", &HybridSshSpec::quickCmdCheckAsync);
+      prototype.registerHybridMethod("authenticateSecPw", &HybridSshSpec::authenticateSecPw);
+      prototype.registerHybridMethod("authenticateSecPwAsync", &HybridSshSpec::authenticateSecPwAsync);
+      prototype.registerHybridMethod("authenticateSecPwPk", &HybridSshSpec::authenticateSecPwPk);
+      prototype.registerHybridMethod("authenticateSecPwPkAsync", &HybridSshSpec::authenticateSecPwPkAsync);
+      prototype.registerHybridMethod("getAuthMethods", &HybridSshSpec::getAuthMethods);
+      prototype.registerHybridMethod("getAuthMethodsAsync", &HybridSshSpec::getAuthMethodsAsync);
+      prototype.registerHybridMethod("getHostKeyFP", &HybridSshSpec::getHostKeyFP);
+      prototype.registerHybridMethod("setAllowedAlgorithms", &HybridSshSpec::setAllowedAlgorithms);
+      prototype.registerHybridMethod("getLastJsonData", &HybridSshSpec::getLastJsonData);
+      prototype.registerHybridMethod("getReceivedSb", &HybridSshSpec::getReceivedSb);
+      prototype.registerHybridMethod("abort", &HybridSshSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat