@chilkat/react-native 11.6.1

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

@@ -0,0 +1,92 @@
+///
+/// HybridJwtSpec.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 `HybridPrivateKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPrivateKeySpec; }
+// Forward declaration of `HybridPublicKeySpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridPublicKeySpec; }
+// Forward declaration of `HybridCertSpec` to properly resolve imports.
+namespace margelo::nitro::chilkat { class HybridCertSpec; }
+
+#include <string>
+#include <memory>
+#include "HybridPrivateKeySpec.hpp"
+#include "HybridPublicKeySpec.hpp"
+#include "HybridCertSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Jwt`
+   * Inherit this class to create instances of `HybridJwtSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridJwt: public HybridJwtSpec {
+   * public:
+   *   HybridJwt(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridJwtSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridJwtSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridJwtSpec() 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 getAutoCompact() = 0;
+      virtual void setAutoCompact(bool autoCompact) = 0;
+      virtual std::string getUncommonOptions() = 0;
+      virtual void setUncommonOptions(const std::string& uncommonOptions) = 0;
+
+    public:
+      // Methods
+      virtual std::string createJwt(const std::string& header, const std::string& payload, const std::string& password) = 0;
+      virtual std::string createJwtPk(const std::string& header, const std::string& payload, const std::shared_ptr<HybridPrivateKeySpec>& key) = 0;
+      virtual double genNumericDate(double numSecOffset) = 0;
+      virtual std::string getHeader(const std::string& token) = 0;
+      virtual std::string getPayload(const std::string& token) = 0;
+      virtual bool isTimeValid(const std::string& jwt, double leeway) = 0;
+      virtual void verifyJwt(const std::string& token, const std::string& password) = 0;
+      virtual void verifyJwtPk(const std::string& token, const std::shared_ptr<HybridPublicKeySpec>& key) = 0;
+      virtual std::string createJwtCert(const std::string& header, const std::string& payload, const std::shared_ptr<HybridCertSpec>& cert) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Jwt";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,44 @@
+///
+/// HybridLogSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridLogSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridLogSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridLogSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridLogSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridLogSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridLogSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridLogSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridLogSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridLogSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridLogSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridLogSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridLogSpec::setLastMethodSuccess);
+      prototype.registerHybridMethod("clear", &HybridLogSpec::clear);
+      prototype.registerHybridMethod("enterContext", &HybridLogSpec::enterContext);
+      prototype.registerHybridMethod("leaveContext", &HybridLogSpec::leaveContext);
+      prototype.registerHybridMethod("logData", &HybridLogSpec::logData);
+      prototype.registerHybridMethod("logDataMax", &HybridLogSpec::logDataMax);
+      prototype.registerHybridMethod("logDateTime", &HybridLogSpec::logDateTime);
+      prototype.registerHybridMethod("logError", &HybridLogSpec::logError);
+      prototype.registerHybridMethod("logInfo", &HybridLogSpec::logInfo);
+      prototype.registerHybridMethod("logInt", &HybridLogSpec::logInt);
+      prototype.registerHybridMethod("logInt64", &HybridLogSpec::logInt64);
+      prototype.registerHybridMethod("logTimestamp", &HybridLogSpec::logTimestamp);
+      prototype.registerHybridMethod("logDataHex2", &HybridLogSpec::logDataHex2);
+      prototype.registerHybridMethod("logDataBase64_2", &HybridLogSpec::logDataBase64_2);
+      prototype.registerHybridMethod("logHash2", &HybridLogSpec::logHash2);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,85 @@
+///
+/// HybridLogSpec.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 <NitroModules/ArrayBuffer.hpp>
+
+namespace margelo::nitro::chilkat {
+
+  using namespace margelo::nitro;
+
+  /**
+   * An abstract base class for `Log`
+   * Inherit this class to create instances of `HybridLogSpec` in C++.
+   * You must explicitly call `HybridObject`'s constructor yourself, because it is virtual.
+   * @example
+   * ```cpp
+   * class HybridLog: public HybridLogSpec {
+   * public:
+   *   HybridLog(...): HybridObject(TAG) { ... }
+   *   // ...
+   * };
+   * ```
+   */
+  class HybridLogSpec: public virtual HybridObject {
+    public:
+      // Constructor
+      explicit HybridLogSpec(): HybridObject(TAG) { }
+
+      // Destructor
+      ~HybridLogSpec() 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;
+
+    public:
+      // Methods
+      virtual void clear(const std::string& initialTag) = 0;
+      virtual void enterContext(const std::string& tag) = 0;
+      virtual void leaveContext() = 0;
+      virtual void logData(const std::string& tag, const std::string& message) = 0;
+      virtual void logDataMax(const std::string& tag, const std::string& message, double maxNumChars) = 0;
+      virtual void logDateTime(const std::string& tag, bool gmt) = 0;
+      virtual void logError(const std::string& message) = 0;
+      virtual void logInfo(const std::string& message) = 0;
+      virtual void logInt(const std::string& tag, double value) = 0;
+      virtual void logInt64(const std::string& tag, double value) = 0;
+      virtual void logTimestamp(const std::string& tag) = 0;
+      virtual void logDataHex2(const std::string& tag, const std::shared_ptr<ArrayBuffer>& byteData) = 0;
+      virtual void logDataBase64_2(const std::string& tag, const std::shared_ptr<ArrayBuffer>& byteData) = 0;
+      virtual void logHash2(const std::string& tag, const std::string& hashAlg, const std::shared_ptr<ArrayBuffer>& byteData) = 0;
+
+    protected:
+      // Hybrid Setup
+      void loadHybridMethods() override;
+
+    protected:
+      // Tag for logging
+      static constexpr auto TAG = "Log";
+  };
+
+} // namespace margelo::nitro::chilkat

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

@@ -0,0 +1,311 @@
+///
+/// HybridMailManSpec.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridMailManSpec.hpp"
+
+namespace margelo::nitro::chilkat {
+
+  void HybridMailManSpec::loadHybridMethods() {
+    // load base methods/properties
+    HybridObject::loadHybridMethods();
+    // load custom methods/properties
+    registerHybrids(this, [](Prototype& prototype) {
+      prototype.registerHybridGetter("lastErrorHtml", &HybridMailManSpec::getLastErrorHtml);
+      prototype.registerHybridGetter("lastErrorText", &HybridMailManSpec::getLastErrorText);
+      prototype.registerHybridGetter("lastErrorXml", &HybridMailManSpec::getLastErrorXml);
+      prototype.registerHybridGetter("version", &HybridMailManSpec::getVersion);
+      prototype.registerHybridGetter("debugLogFilePath", &HybridMailManSpec::getDebugLogFilePath);
+      prototype.registerHybridSetter("debugLogFilePath", &HybridMailManSpec::setDebugLogFilePath);
+      prototype.registerHybridGetter("verboseLogging", &HybridMailManSpec::getVerboseLogging);
+      prototype.registerHybridSetter("verboseLogging", &HybridMailManSpec::setVerboseLogging);
+      prototype.registerHybridGetter("lastMethodSuccess", &HybridMailManSpec::getLastMethodSuccess);
+      prototype.registerHybridSetter("lastMethodSuccess", &HybridMailManSpec::setLastMethodSuccess);
+      prototype.registerHybridGetter("abortCurrent", &HybridMailManSpec::getAbortCurrent);
+      prototype.registerHybridSetter("abortCurrent", &HybridMailManSpec::setAbortCurrent);
+      prototype.registerHybridGetter("allOrNone", &HybridMailManSpec::getAllOrNone);
+      prototype.registerHybridSetter("allOrNone", &HybridMailManSpec::setAllOrNone);
+      prototype.registerHybridGetter("autoFix", &HybridMailManSpec::getAutoFix);
+      prototype.registerHybridSetter("autoFix", &HybridMailManSpec::setAutoFix);
+      prototype.registerHybridGetter("autoGenMessageId", &HybridMailManSpec::getAutoGenMessageId);
+      prototype.registerHybridSetter("autoGenMessageId", &HybridMailManSpec::setAutoGenMessageId);
+      prototype.registerHybridGetter("autoSmtpRset", &HybridMailManSpec::getAutoSmtpRset);
+      prototype.registerHybridSetter("autoSmtpRset", &HybridMailManSpec::setAutoSmtpRset);
+      prototype.registerHybridGetter("autoUnwrapSecurity", &HybridMailManSpec::getAutoUnwrapSecurity);
+      prototype.registerHybridSetter("autoUnwrapSecurity", &HybridMailManSpec::setAutoUnwrapSecurity);
+      prototype.registerHybridGetter("clientIpAddress", &HybridMailManSpec::getClientIpAddress);
+      prototype.registerHybridSetter("clientIpAddress", &HybridMailManSpec::setClientIpAddress);
+      prototype.registerHybridGetter("connectFailReason", &HybridMailManSpec::getConnectFailReason);
+      prototype.registerHybridGetter("connectTimeout", &HybridMailManSpec::getConnectTimeout);
+      prototype.registerHybridSetter("connectTimeout", &HybridMailManSpec::setConnectTimeout);
+      prototype.registerHybridGetter("dsnEnvid", &HybridMailManSpec::getDsnEnvid);
+      prototype.registerHybridSetter("dsnEnvid", &HybridMailManSpec::setDsnEnvid);
+      prototype.registerHybridGetter("dsnNotify", &HybridMailManSpec::getDsnNotify);
+      prototype.registerHybridSetter("dsnNotify", &HybridMailManSpec::setDsnNotify);
+      prototype.registerHybridGetter("dsnRet", &HybridMailManSpec::getDsnRet);
+      prototype.registerHybridSetter("dsnRet", &HybridMailManSpec::setDsnRet);
+      prototype.registerHybridGetter("embedCertChain", &HybridMailManSpec::getEmbedCertChain);
+      prototype.registerHybridSetter("embedCertChain", &HybridMailManSpec::setEmbedCertChain);
+      prototype.registerHybridGetter("filter", &HybridMailManSpec::getFilter);
+      prototype.registerHybridSetter("filter", &HybridMailManSpec::setFilter);
+      prototype.registerHybridGetter("heartbeatMs", &HybridMailManSpec::getHeartbeatMs);
+      prototype.registerHybridSetter("heartbeatMs", &HybridMailManSpec::setHeartbeatMs);
+      prototype.registerHybridGetter("heloHostname", &HybridMailManSpec::getHeloHostname);
+      prototype.registerHybridSetter("heloHostname", &HybridMailManSpec::setHeloHostname);
+      prototype.registerHybridGetter("httpProxyAuthMethod", &HybridMailManSpec::getHttpProxyAuthMethod);
+      prototype.registerHybridSetter("httpProxyAuthMethod", &HybridMailManSpec::setHttpProxyAuthMethod);
+      prototype.registerHybridGetter("httpProxyDomain", &HybridMailManSpec::getHttpProxyDomain);
+      prototype.registerHybridSetter("httpProxyDomain", &HybridMailManSpec::setHttpProxyDomain);
+      prototype.registerHybridGetter("httpProxyHostname", &HybridMailManSpec::getHttpProxyHostname);
+      prototype.registerHybridSetter("httpProxyHostname", &HybridMailManSpec::setHttpProxyHostname);
+      prototype.registerHybridGetter("httpProxyPassword", &HybridMailManSpec::getHttpProxyPassword);
+      prototype.registerHybridSetter("httpProxyPassword", &HybridMailManSpec::setHttpProxyPassword);
+      prototype.registerHybridGetter("httpProxyPort", &HybridMailManSpec::getHttpProxyPort);
+      prototype.registerHybridSetter("httpProxyPort", &HybridMailManSpec::setHttpProxyPort);
+      prototype.registerHybridGetter("httpProxyUsername", &HybridMailManSpec::getHttpProxyUsername);
+      prototype.registerHybridSetter("httpProxyUsername", &HybridMailManSpec::setHttpProxyUsername);
+      prototype.registerHybridGetter("immediateDelete", &HybridMailManSpec::getImmediateDelete);
+      prototype.registerHybridSetter("immediateDelete", &HybridMailManSpec::setImmediateDelete);
+      prototype.registerHybridGetter("includeRootCert", &HybridMailManSpec::getIncludeRootCert);
+      prototype.registerHybridSetter("includeRootCert", &HybridMailManSpec::setIncludeRootCert);
+      prototype.registerHybridGetter("isPop3Connected", &HybridMailManSpec::getIsPop3Connected);
+      prototype.registerHybridGetter("isSmtpConnected", &HybridMailManSpec::getIsSmtpConnected);
+      prototype.registerHybridGetter("lastSmtpStatus", &HybridMailManSpec::getLastSmtpStatus);
+      prototype.registerHybridGetter("logMailReceivedFilename", &HybridMailManSpec::getLogMailReceivedFilename);
+      prototype.registerHybridSetter("logMailReceivedFilename", &HybridMailManSpec::setLogMailReceivedFilename);
+      prototype.registerHybridGetter("logMailSentFilename", &HybridMailManSpec::getLogMailSentFilename);
+      prototype.registerHybridSetter("logMailSentFilename", &HybridMailManSpec::setLogMailSentFilename);
+      prototype.registerHybridGetter("mailHost", &HybridMailManSpec::getMailHost);
+      prototype.registerHybridSetter("mailHost", &HybridMailManSpec::setMailHost);
+      prototype.registerHybridGetter("mailPort", &HybridMailManSpec::getMailPort);
+      prototype.registerHybridSetter("mailPort", &HybridMailManSpec::setMailPort);
+      prototype.registerHybridGetter("maxCount", &HybridMailManSpec::getMaxCount);
+      prototype.registerHybridSetter("maxCount", &HybridMailManSpec::setMaxCount);
+      prototype.registerHybridGetter("oAuth2AccessToken", &HybridMailManSpec::getOAuth2AccessToken);
+      prototype.registerHybridSetter("oAuth2AccessToken", &HybridMailManSpec::setOAuth2AccessToken);
+      prototype.registerHybridGetter("opaqueSigning", &HybridMailManSpec::getOpaqueSigning);
+      prototype.registerHybridSetter("opaqueSigning", &HybridMailManSpec::setOpaqueSigning);
+      prototype.registerHybridGetter("p7mEncryptAttachFilename", &HybridMailManSpec::getP7mEncryptAttachFilename);
+      prototype.registerHybridSetter("p7mEncryptAttachFilename", &HybridMailManSpec::setP7mEncryptAttachFilename);
+      prototype.registerHybridGetter("p7mSigAttachFilename", &HybridMailManSpec::getP7mSigAttachFilename);
+      prototype.registerHybridSetter("p7mSigAttachFilename", &HybridMailManSpec::setP7mSigAttachFilename);
+      prototype.registerHybridGetter("p7sSigAttachFilename", &HybridMailManSpec::getP7sSigAttachFilename);
+      prototype.registerHybridSetter("p7sSigAttachFilename", &HybridMailManSpec::setP7sSigAttachFilename);
+      prototype.registerHybridGetter("percentDoneScale", &HybridMailManSpec::getPercentDoneScale);
+      prototype.registerHybridSetter("percentDoneScale", &HybridMailManSpec::setPercentDoneScale);
+      prototype.registerHybridGetter("pop3SPA", &HybridMailManSpec::getPop3SPA);
+      prototype.registerHybridSetter("pop3SPA", &HybridMailManSpec::setPop3SPA);
+      prototype.registerHybridGetter("pop3SessionId", &HybridMailManSpec::getPop3SessionId);
+      prototype.registerHybridGetter("pop3SessionLog", &HybridMailManSpec::getPop3SessionLog);
+      prototype.registerHybridGetter("pop3SslServerCertVerified", &HybridMailManSpec::getPop3SslServerCertVerified);
+      prototype.registerHybridGetter("pop3Stls", &HybridMailManSpec::getPop3Stls);
+      prototype.registerHybridSetter("pop3Stls", &HybridMailManSpec::setPop3Stls);
+      prototype.registerHybridGetter("popPassword", &HybridMailManSpec::getPopPassword);
+      prototype.registerHybridSetter("popPassword", &HybridMailManSpec::setPopPassword);
+      prototype.registerHybridGetter("popPasswordBase64", &HybridMailManSpec::getPopPasswordBase64);
+      prototype.registerHybridSetter("popPasswordBase64", &HybridMailManSpec::setPopPasswordBase64);
+      prototype.registerHybridGetter("popSsl", &HybridMailManSpec::getPopSsl);
+      prototype.registerHybridSetter("popSsl", &HybridMailManSpec::setPopSsl);
+      prototype.registerHybridGetter("popUsername", &HybridMailManSpec::getPopUsername);
+      prototype.registerHybridSetter("popUsername", &HybridMailManSpec::setPopUsername);
+      prototype.registerHybridGetter("preferIpv6", &HybridMailManSpec::getPreferIpv6);
+      prototype.registerHybridSetter("preferIpv6", &HybridMailManSpec::setPreferIpv6);
+      prototype.registerHybridGetter("readTimeout", &HybridMailManSpec::getReadTimeout);
+      prototype.registerHybridSetter("readTimeout", &HybridMailManSpec::setReadTimeout);
+      prototype.registerHybridGetter("requireSslCertVerify", &HybridMailManSpec::getRequireSslCertVerify);
+      prototype.registerHybridSetter("requireSslCertVerify", &HybridMailManSpec::setRequireSslCertVerify);
+      prototype.registerHybridGetter("resetDateOnLoad", &HybridMailManSpec::getResetDateOnLoad);
+      prototype.registerHybridSetter("resetDateOnLoad", &HybridMailManSpec::setResetDateOnLoad);
+      prototype.registerHybridGetter("sendBufferSize", &HybridMailManSpec::getSendBufferSize);
+      prototype.registerHybridSetter("sendBufferSize", &HybridMailManSpec::setSendBufferSize);
+      prototype.registerHybridGetter("sizeLimit", &HybridMailManSpec::getSizeLimit);
+      prototype.registerHybridSetter("sizeLimit", &HybridMailManSpec::setSizeLimit);
+      prototype.registerHybridGetter("smtpAuthMethod", &HybridMailManSpec::getSmtpAuthMethod);
+      prototype.registerHybridSetter("smtpAuthMethod", &HybridMailManSpec::setSmtpAuthMethod);
+      prototype.registerHybridGetter("smtpFailReason", &HybridMailManSpec::getSmtpFailReason);
+      prototype.registerHybridGetter("smtpHost", &HybridMailManSpec::getSmtpHost);
+      prototype.registerHybridSetter("smtpHost", &HybridMailManSpec::setSmtpHost);
+      prototype.registerHybridGetter("smtpLoginDomain", &HybridMailManSpec::getSmtpLoginDomain);
+      prototype.registerHybridSetter("smtpLoginDomain", &HybridMailManSpec::setSmtpLoginDomain);
+      prototype.registerHybridGetter("smtpPassword", &HybridMailManSpec::getSmtpPassword);
+      prototype.registerHybridSetter("smtpPassword", &HybridMailManSpec::setSmtpPassword);
+      prototype.registerHybridGetter("smtpPipelining", &HybridMailManSpec::getSmtpPipelining);
+      prototype.registerHybridSetter("smtpPipelining", &HybridMailManSpec::setSmtpPipelining);
+      prototype.registerHybridGetter("smtpPort", &HybridMailManSpec::getSmtpPort);
+      prototype.registerHybridSetter("smtpPort", &HybridMailManSpec::setSmtpPort);
+      prototype.registerHybridGetter("smtpSessionLog", &HybridMailManSpec::getSmtpSessionLog);
+      prototype.registerHybridGetter("smtpSsl", &HybridMailManSpec::getSmtpSsl);
+      prototype.registerHybridSetter("smtpSsl", &HybridMailManSpec::setSmtpSsl);
+      prototype.registerHybridGetter("smtpSslServerCertVerified", &HybridMailManSpec::getSmtpSslServerCertVerified);
+      prototype.registerHybridGetter("smtpUsername", &HybridMailManSpec::getSmtpUsername);
+      prototype.registerHybridSetter("smtpUsername", &HybridMailManSpec::setSmtpUsername);
+      prototype.registerHybridGetter("soRcvBuf", &HybridMailManSpec::getSoRcvBuf);
+      prototype.registerHybridSetter("soRcvBuf", &HybridMailManSpec::setSoRcvBuf);
+      prototype.registerHybridGetter("soSndBuf", &HybridMailManSpec::getSoSndBuf);
+      prototype.registerHybridSetter("soSndBuf", &HybridMailManSpec::setSoSndBuf);
+      prototype.registerHybridGetter("socksHostname", &HybridMailManSpec::getSocksHostname);
+      prototype.registerHybridSetter("socksHostname", &HybridMailManSpec::setSocksHostname);
+      prototype.registerHybridGetter("socksPassword", &HybridMailManSpec::getSocksPassword);
+      prototype.registerHybridSetter("socksPassword", &HybridMailManSpec::setSocksPassword);
+      prototype.registerHybridGetter("socksPort", &HybridMailManSpec::getSocksPort);
+      prototype.registerHybridSetter("socksPort", &HybridMailManSpec::setSocksPort);
+      prototype.registerHybridGetter("socksUsername", &HybridMailManSpec::getSocksUsername);
+      prototype.registerHybridSetter("socksUsername", &HybridMailManSpec::setSocksUsername);
+      prototype.registerHybridGetter("socksVersion", &HybridMailManSpec::getSocksVersion);
+      prototype.registerHybridSetter("socksVersion", &HybridMailManSpec::setSocksVersion);
+      prototype.registerHybridGetter("sslAllowedCiphers", &HybridMailManSpec::getSslAllowedCiphers);
+      prototype.registerHybridSetter("sslAllowedCiphers", &HybridMailManSpec::setSslAllowedCiphers);
+      prototype.registerHybridGetter("sslProtocol", &HybridMailManSpec::getSslProtocol);
+      prototype.registerHybridSetter("sslProtocol", &HybridMailManSpec::setSslProtocol);
+      prototype.registerHybridGetter("startTLS", &HybridMailManSpec::getStartTLS);
+      prototype.registerHybridSetter("startTLS", &HybridMailManSpec::setStartTLS);
+      prototype.registerHybridGetter("tlsCipherSuite", &HybridMailManSpec::getTlsCipherSuite);
+      prototype.registerHybridGetter("tlsPinSet", &HybridMailManSpec::getTlsPinSet);
+      prototype.registerHybridSetter("tlsPinSet", &HybridMailManSpec::setTlsPinSet);
+      prototype.registerHybridGetter("tlsVersion", &HybridMailManSpec::getTlsVersion);
+      prototype.registerHybridGetter("useApop", &HybridMailManSpec::getUseApop);
+      prototype.registerHybridSetter("useApop", &HybridMailManSpec::setUseApop);
+      prototype.registerHybridGetter("startTLSifPossible", &HybridMailManSpec::getStartTLSifPossible);
+      prototype.registerHybridSetter("startTLSifPossible", &HybridMailManSpec::setStartTLSifPossible);
+      prototype.registerHybridGetter("uncommonOptions", &HybridMailManSpec::getUncommonOptions);
+      prototype.registerHybridSetter("uncommonOptions", &HybridMailManSpec::setUncommonOptions);
+      prototype.registerHybridGetter("lastSmtpStatusMsg", &HybridMailManSpec::getLastSmtpStatusMsg);
+      prototype.registerHybridGetter("pop3StlsIfPossible", &HybridMailManSpec::getPop3StlsIfPossible);
+      prototype.registerHybridSetter("pop3StlsIfPossible", &HybridMailManSpec::setPop3StlsIfPossible);
+      prototype.registerHybridGetter("smtpMailFrom", &HybridMailManSpec::getSmtpMailFrom);
+      prototype.registerHybridSetter("smtpMailFrom", &HybridMailManSpec::setSmtpMailFrom);
+      prototype.registerHybridGetter("enableSecrets", &HybridMailManSpec::getEnableSecrets);
+      prototype.registerHybridSetter("enableSecrets", &HybridMailManSpec::setEnableSecrets);
+      prototype.registerHybridGetter("requireHostnameMatch", &HybridMailManSpec::getRequireHostnameMatch);
+      prototype.registerHybridSetter("requireHostnameMatch", &HybridMailManSpec::setRequireHostnameMatch);
+      prototype.registerHybridGetter("sniHostname", &HybridMailManSpec::getSniHostname);
+      prototype.registerHybridSetter("sniHostname", &HybridMailManSpec::setSniHostname);
+      prototype.registerHybridGetter("onPercentDone", &HybridMailManSpec::getOnPercentDone);
+      prototype.registerHybridSetter("onPercentDone", &HybridMailManSpec::setOnPercentDone);
+      prototype.registerHybridGetter("onProgressInfo", &HybridMailManSpec::getOnProgressInfo);
+      prototype.registerHybridSetter("onProgressInfo", &HybridMailManSpec::setOnProgressInfo);
+      prototype.registerHybridMethod("addPfxSourceFile", &HybridMailManSpec::addPfxSourceFile);
+      prototype.registerHybridMethod("checkMail", &HybridMailManSpec::checkMail);
+      prototype.registerHybridMethod("checkMailAsync", &HybridMailManSpec::checkMailAsync);
+      prototype.registerHybridMethod("clearPop3SessionLog", &HybridMailManSpec::clearPop3SessionLog);
+      prototype.registerHybridMethod("clearSmtpSessionLog", &HybridMailManSpec::clearSmtpSessionLog);
+      prototype.registerHybridMethod("closeSmtpConnection", &HybridMailManSpec::closeSmtpConnection);
+      prototype.registerHybridMethod("closeSmtpConnectionAsync", &HybridMailManSpec::closeSmtpConnectionAsync);
+      prototype.registerHybridMethod("deleteBundle", &HybridMailManSpec::deleteBundle);
+      prototype.registerHybridMethod("deleteBundleAsync", &HybridMailManSpec::deleteBundleAsync);
+      prototype.registerHybridMethod("deleteByMsgnum", &HybridMailManSpec::deleteByMsgnum);
+      prototype.registerHybridMethod("deleteByMsgnumAsync", &HybridMailManSpec::deleteByMsgnumAsync);
+      prototype.registerHybridMethod("deleteByUidl", &HybridMailManSpec::deleteByUidl);
+      prototype.registerHybridMethod("deleteByUidlAsync", &HybridMailManSpec::deleteByUidlAsync);
+      prototype.registerHybridMethod("deleteEmail", &HybridMailManSpec::deleteEmail);
+      prototype.registerHybridMethod("deleteEmailAsync", &HybridMailManSpec::deleteEmailAsync);
+      prototype.registerHybridMethod("getMailboxCount", &HybridMailManSpec::getMailboxCount);
+      prototype.registerHybridMethod("getMailboxCountAsync", &HybridMailManSpec::getMailboxCountAsync);
+      prototype.registerHybridMethod("getMailboxInfoXml", &HybridMailManSpec::getMailboxInfoXml);
+      prototype.registerHybridMethod("getMailboxInfoXmlAsync", &HybridMailManSpec::getMailboxInfoXmlAsync);
+      prototype.registerHybridMethod("getMailboxSize", &HybridMailManSpec::getMailboxSize);
+      prototype.registerHybridMethod("getMailboxSizeAsync", &HybridMailManSpec::getMailboxSizeAsync);
+      prototype.registerHybridMethod("getSizeByUidl", &HybridMailManSpec::getSizeByUidl);
+      prototype.registerHybridMethod("getSizeByUidlAsync", &HybridMailManSpec::getSizeByUidlAsync);
+      prototype.registerHybridMethod("isSmtpDsnCapable", &HybridMailManSpec::isSmtpDsnCapable);
+      prototype.registerHybridMethod("isSmtpDsnCapableAsync", &HybridMailManSpec::isSmtpDsnCapableAsync);
+      prototype.registerHybridMethod("openSmtpConnection", &HybridMailManSpec::openSmtpConnection);
+      prototype.registerHybridMethod("openSmtpConnectionAsync", &HybridMailManSpec::openSmtpConnectionAsync);
+      prototype.registerHybridMethod("pop3Authenticate", &HybridMailManSpec::pop3Authenticate);
+      prototype.registerHybridMethod("pop3AuthenticateAsync", &HybridMailManSpec::pop3AuthenticateAsync);
+      prototype.registerHybridMethod("pop3BeginSession", &HybridMailManSpec::pop3BeginSession);
+      prototype.registerHybridMethod("pop3BeginSessionAsync", &HybridMailManSpec::pop3BeginSessionAsync);
+      prototype.registerHybridMethod("pop3Connect", &HybridMailManSpec::pop3Connect);
+      prototype.registerHybridMethod("pop3ConnectAsync", &HybridMailManSpec::pop3ConnectAsync);
+      prototype.registerHybridMethod("pop3EndSession", &HybridMailManSpec::pop3EndSession);
+      prototype.registerHybridMethod("pop3EndSessionAsync", &HybridMailManSpec::pop3EndSessionAsync);
+      prototype.registerHybridMethod("pop3EndSessionNoQuit", &HybridMailManSpec::pop3EndSessionNoQuit);
+      prototype.registerHybridMethod("pop3EndSessionNoQuitAsync", &HybridMailManSpec::pop3EndSessionNoQuitAsync);
+      prototype.registerHybridMethod("pop3Noop", &HybridMailManSpec::pop3Noop);
+      prototype.registerHybridMethod("pop3NoopAsync", &HybridMailManSpec::pop3NoopAsync);
+      prototype.registerHybridMethod("pop3Reset", &HybridMailManSpec::pop3Reset);
+      prototype.registerHybridMethod("pop3ResetAsync", &HybridMailManSpec::pop3ResetAsync);
+      prototype.registerHybridMethod("pop3SendRawCommand", &HybridMailManSpec::pop3SendRawCommand);
+      prototype.registerHybridMethod("pop3SendRawCommandAsync", &HybridMailManSpec::pop3SendRawCommandAsync);
+      prototype.registerHybridMethod("quickSend", &HybridMailManSpec::quickSend);
+      prototype.registerHybridMethod("quickSendAsync", &HybridMailManSpec::quickSendAsync);
+      prototype.registerHybridMethod("renderToMime", &HybridMailManSpec::renderToMime);
+      prototype.registerHybridMethod("sendBundle", &HybridMailManSpec::sendBundle);
+      prototype.registerHybridMethod("sendBundleAsync", &HybridMailManSpec::sendBundleAsync);
+      prototype.registerHybridMethod("sendEmail", &HybridMailManSpec::sendEmail);
+      prototype.registerHybridMethod("sendEmailAsync", &HybridMailManSpec::sendEmailAsync);
+      prototype.registerHybridMethod("sendMime", &HybridMailManSpec::sendMime);
+      prototype.registerHybridMethod("sendMimeAsync", &HybridMailManSpec::sendMimeAsync);
+      prototype.registerHybridMethod("setDecryptCert", &HybridMailManSpec::setDecryptCert);
+      prototype.registerHybridMethod("setDecryptCert2", &HybridMailManSpec::setDecryptCert2);
+      prototype.registerHybridMethod("setSslClientCert", &HybridMailManSpec::setSslClientCert);
+      prototype.registerHybridMethod("setSslClientCertPem", &HybridMailManSpec::setSslClientCertPem);
+      prototype.registerHybridMethod("setSslClientCertPfx", &HybridMailManSpec::setSslClientCertPfx);
+      prototype.registerHybridMethod("smtpAuthenticate", &HybridMailManSpec::smtpAuthenticate);
+      prototype.registerHybridMethod("smtpAuthenticateAsync", &HybridMailManSpec::smtpAuthenticateAsync);
+      prototype.registerHybridMethod("smtpConnect", &HybridMailManSpec::smtpConnect);
+      prototype.registerHybridMethod("smtpConnectAsync", &HybridMailManSpec::smtpConnectAsync);
+      prototype.registerHybridMethod("smtpNoop", &HybridMailManSpec::smtpNoop);
+      prototype.registerHybridMethod("smtpNoopAsync", &HybridMailManSpec::smtpNoopAsync);
+      prototype.registerHybridMethod("smtpReset", &HybridMailManSpec::smtpReset);
+      prototype.registerHybridMethod("smtpResetAsync", &HybridMailManSpec::smtpResetAsync);
+      prototype.registerHybridMethod("smtpSendRawCommand", &HybridMailManSpec::smtpSendRawCommand);
+      prototype.registerHybridMethod("smtpSendRawCommandAsync", &HybridMailManSpec::smtpSendRawCommandAsync);
+      prototype.registerHybridMethod("sshAuthenticatePk", &HybridMailManSpec::sshAuthenticatePk);
+      prototype.registerHybridMethod("sshAuthenticatePkAsync", &HybridMailManSpec::sshAuthenticatePkAsync);
+      prototype.registerHybridMethod("sshAuthenticatePw", &HybridMailManSpec::sshAuthenticatePw);
+      prototype.registerHybridMethod("sshAuthenticatePwAsync", &HybridMailManSpec::sshAuthenticatePwAsync);
+      prototype.registerHybridMethod("sshCloseTunnel", &HybridMailManSpec::sshCloseTunnel);
+      prototype.registerHybridMethod("sshCloseTunnelAsync", &HybridMailManSpec::sshCloseTunnelAsync);
+      prototype.registerHybridMethod("sshOpenTunnel", &HybridMailManSpec::sshOpenTunnel);
+      prototype.registerHybridMethod("sshOpenTunnelAsync", &HybridMailManSpec::sshOpenTunnelAsync);
+      prototype.registerHybridMethod("useCertVault", &HybridMailManSpec::useCertVault);
+      prototype.registerHybridMethod("useSsh", &HybridMailManSpec::useSsh);
+      prototype.registerHybridMethod("useSshTunnel", &HybridMailManSpec::useSshTunnel);
+      prototype.registerHybridMethod("verifyPopConnection", &HybridMailManSpec::verifyPopConnection);
+      prototype.registerHybridMethod("verifyPopConnectionAsync", &HybridMailManSpec::verifyPopConnectionAsync);
+      prototype.registerHybridMethod("verifyPopLogin", &HybridMailManSpec::verifyPopLogin);
+      prototype.registerHybridMethod("verifyPopLoginAsync", &HybridMailManSpec::verifyPopLoginAsync);
+      prototype.registerHybridMethod("verifyRecips", &HybridMailManSpec::verifyRecips);
+      prototype.registerHybridMethod("verifyRecipsAsync", &HybridMailManSpec::verifyRecipsAsync);
+      prototype.registerHybridMethod("verifySmtpConnection", &HybridMailManSpec::verifySmtpConnection);
+      prototype.registerHybridMethod("verifySmtpConnectionAsync", &HybridMailManSpec::verifySmtpConnectionAsync);
+      prototype.registerHybridMethod("verifySmtpLogin", &HybridMailManSpec::verifySmtpLogin);
+      prototype.registerHybridMethod("verifySmtpLoginAsync", &HybridMailManSpec::verifySmtpLoginAsync);
+      prototype.registerHybridMethod("renderToMimeSb", &HybridMailManSpec::renderToMimeSb);
+      prototype.registerHybridMethod("renderToMimeBd", &HybridMailManSpec::renderToMimeBd);
+      prototype.registerHybridMethod("setPassword", &HybridMailManSpec::setPassword);
+      prototype.registerHybridMethod("sendMimeBd", &HybridMailManSpec::sendMimeBd);
+      prototype.registerHybridMethod("sendMimeBdAsync", &HybridMailManSpec::sendMimeBdAsync);
+      prototype.registerHybridMethod("fetchMimeBd", &HybridMailManSpec::fetchMimeBd);
+      prototype.registerHybridMethod("fetchMimeBdAsync", &HybridMailManSpec::fetchMimeBdAsync);
+      prototype.registerHybridMethod("getLastJsonData", &HybridMailManSpec::getLastJsonData);
+      prototype.registerHybridMethod("getServerCert", &HybridMailManSpec::getServerCert);
+      prototype.registerHybridMethod("fetchAll", &HybridMailManSpec::fetchAll);
+      prototype.registerHybridMethod("fetchAllAsync", &HybridMailManSpec::fetchAllAsync);
+      prototype.registerHybridMethod("fetchRange", &HybridMailManSpec::fetchRange);
+      prototype.registerHybridMethod("fetchRangeAsync", &HybridMailManSpec::fetchRangeAsync);
+      prototype.registerHybridMethod("fetchOne", &HybridMailManSpec::fetchOne);
+      prototype.registerHybridMethod("fetchOneAsync", &HybridMailManSpec::fetchOneAsync);
+      prototype.registerHybridMethod("fetchByUidl", &HybridMailManSpec::fetchByUidl);
+      prototype.registerHybridMethod("fetchByUidlAsync", &HybridMailManSpec::fetchByUidlAsync);
+      prototype.registerHybridMethod("fetchUidlSet", &HybridMailManSpec::fetchUidlSet);
+      prototype.registerHybridMethod("fetchUidlSetAsync", &HybridMailManSpec::fetchUidlSetAsync);
+      prototype.registerHybridMethod("fetchFull", &HybridMailManSpec::fetchFull);
+      prototype.registerHybridMethod("fetchFullAsync", &HybridMailManSpec::fetchFullAsync);
+      prototype.registerHybridMethod("loadMbxFile", &HybridMailManSpec::loadMbxFile);
+      prototype.registerHybridMethod("fetchUidls", &HybridMailManSpec::fetchUidls);
+      prototype.registerHybridMethod("fetchUidlsAsync", &HybridMailManSpec::fetchUidlsAsync);
+      prototype.registerHybridMethod("addPfxSourceBd", &HybridMailManSpec::addPfxSourceBd);
+      prototype.registerHybridMethod("fetchMimeByMsgnumBd", &HybridMailManSpec::fetchMimeByMsgnumBd);
+      prototype.registerHybridMethod("fetchMimeByMsgnumBdAsync", &HybridMailManSpec::fetchMimeByMsgnumBdAsync);
+      prototype.registerHybridMethod("deleteUidlSet", &HybridMailManSpec::deleteUidlSet);
+      prototype.registerHybridMethod("deleteUidlSetAsync", &HybridMailManSpec::deleteUidlSetAsync);
+      prototype.registerHybridMethod("abort", &HybridMailManSpec::abort);
+    });
+  }
+
+} // namespace margelo::nitro::chilkat